require "spec_helper"

describe Berkshelf::CookbookStore do
  describe "ClassMethods" do
    describe "::instance"
    describe "::import"

    describe "::new" do
      it "creates the storage_path" do
        storage_path = tmp_path.join("random_storage")
        Berkshelf::CookbookStore.new(storage_path)

        expect(storage_path).to exist
      end
    end
  end

  subject { Berkshelf::CookbookStore.new(tmp_path.join("cbstore_rspec")) }

  describe "#cookbook_path" do
    let(:cookbook_name) { "nginx" }
    let(:cookbook_version) { "0.101.2" }
    let(:path) { subject.cookbook_path(cookbook_name, cookbook_version) }

    it "returns an instance of Pathname" do
      expect(path).to be_a(Pathname)
    end

    it "returns a the filepath within the storage path" do
      expect(path.dirname).to eq(subject.storage_path)
    end

    it "returns a basename containing the cookbook name and version separated by a dash" do
      expect(path.basename.to_s).to eq("#{cookbook_name}-#{cookbook_version}")
    end
  end

  describe "#satisfy" do
    let(:name) { "nginx" }
    let(:version) { "0.101.4" }
    let(:constraint) { Semverse::Constraint.new("~> 0.101.2") }
    let(:cached_one) { double("cached-one", name: name, version: Semverse::Version.new(version)) }
    let(:cached_two) { double("cached-two", name: "mysql", version: Semverse::Version.new("1.2.6")) }

    before { allow(subject).to receive(:cookbooks).and_return([cached_one, cached_two]) }

    it "gets and returns the the CachedCookbook best matching the name and constraint" do
      expect(subject).to receive(:cookbook).with(name, version).and_return(cached_one)
      result = subject.satisfy(name, constraint)

      expect(result).to eq(cached_one)
    end

    context "when there are no cookbooks in the cookbook store" do
      before { allow(subject).to receive(:cookbooks).and_return([]) }

      it "returns nil" do
        result = subject.satisfy(name, constraint)
        expect(result).to be_nil
      end
    end

    context "when there is no matching cookbook for the given name and constraint" do
      let(:version) { Semverse::Version.new("1.0.0") }
      let(:constraint) { Semverse::Constraint.new("= 0.1.0") }

      before { allow(subject).to receive(:cookbooks).and_return([ double("badcache", name: "none", version: version) ]) }

      it "returns nil if there is no matching cookbook for the name and constraint" do
        result = subject.satisfy(name, constraint)
        expect(result).to be_nil
      end
    end
  end

  describe "#cookbook" do
    subject { Berkshelf::CookbookStore.new(fixtures_path.join("cookbooks")) }

    it "returns a CachedCookbook if the specified cookbook version exists" do
      expect(subject.cookbook("example_cookbook", "0.5.0")).to be_a(Berkshelf::CachedCookbook)
    end

    it "returns nil if the specified cookbook version does not exist" do
      expect(subject.cookbook("doesnotexist", "0.1.0")).to be_nil
    end
  end

  describe "#cookbooks" do
    before do
      generate_cookbook(subject.storage_path, "nginx", "0.101.2")
      generate_cookbook(subject.storage_path, "mysql", "1.2.6")
    end

    it "returns a list of CachedCookbooks" do
      subject.cookbooks.each do |cookbook|
        expect(cookbook).to be_a(Berkshelf::CachedCookbook)
      end
    end

    it "contains a CachedCookbook for every cookbook in the storage path" do
      expect(subject.cookbooks.size).to eq(2)
    end

    context "given a value for the filter parameter" do
      it "returns only the CachedCookbooks whose name match the filter" do
        expect(subject.cookbooks("mysql").size).to eq(1)
      end
    end

    context "when a there is a cookbook without a name attribute" do
      before do
        generate_cookbook(subject.storage_path, "foo", "3.0.1", without_name: true)
      end

      it "omits the broken cookbook" do
        expect(subject.cookbooks("foo")).to be_empty
      end
    end
  end

  describe "#import"
end