puppet-library 0.2.0 → 0.3.0

data/spec/forge/multi_spec.rb

@@ -0,0 +1,314 @@
+# -*- encoding: utf-8 -*-
+# Puppet Library
+# Copyright (C) 2014 drrb
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'spec_helper'
+
+class Hash
+    def deep_clone
+        other = clone
+        keys.each do |key|
+            other[key] = self[key].clone
+        end
+        other
+    end
+end
+
+module PuppetLibrary::Forge
+    describe Multi do
+        let(:subforge_one) { double('subforge_one').as_null_object }
+        let(:subforge_two) { double('subforge_two').as_null_object }
+        let(:multi_forge) do
+            forge = Multi.new
+            forge.add_forge(subforge_one)
+            forge.add_forge(subforge_two)
+            return forge
+        end
+
+        describe "#search_modules" do
+            context "when no modules match in any subforge" do
+                it "returns an empty array" do
+                    expect(subforge_one).to receive(:search_modules).with("apache").and_return([])
+                    expect(subforge_two).to receive(:search_modules).with("apache").and_return([])
+
+                    result = multi_forge.search_modules("apache")
+
+                    expect(result).to eq []
+                end
+            end
+
+            context "when modules match in subforges" do
+                it "returns an array with all of them" do
+                    apache = { "author" => "puppetlabs", "full_name" => "puppetlabs/apache", "version" => "1"}
+                    concat = { "author" => "puppetlabs", "full_name" => "puppetlabs/concat", "version" => "1"}
+                    expect(subforge_one).to receive(:search_modules).with("puppetlabs").and_return([apache])
+                    expect(subforge_two).to receive(:search_modules).with("puppetlabs").and_return([concat])
+
+                    result = multi_forge.search_modules("puppetlabs")
+
+                    result = result.sort_by {|r| r["full_name"]}
+                    expect(result).to eq [apache, concat]
+                end
+            end
+
+            context "when modules match in subforges that overlap" do
+                it "favors the details of the ones in the first repository" do
+                    apache_1 = { "author" => "puppetlabs", "full_name" => "puppetlabs/apache", "desc" => "one", "version" => "1"}
+                    apache_2 = { "author" => "puppetlabs", "full_name" => "puppetlabs/apache", "desc" => "two", "version" => "2"}
+                    expect(subforge_one).to receive(:search_modules).with("puppetlabs").and_return([apache_1])
+                    expect(subforge_two).to receive(:search_modules).with("puppetlabs").and_return([apache_2])
+
+                    result = multi_forge.search_modules("puppetlabs")
+
+                    expect(result.size).to eq 1
+                    expect(result.first["desc"]).to eq "one"
+                end
+
+                it "sets the version to the maximum version" do
+                    apache_1 = { "author" => "puppetlabs", "full_name" => "puppetlabs/apache", "desc" => "one", "version" => "1"}
+                    apache_2 = { "author" => "puppetlabs", "full_name" => "puppetlabs/apache", "desc" => "two", "version" => "2"}
+                    expect(subforge_one).to receive(:search_modules).with("puppetlabs").and_return([apache_1])
+                    expect(subforge_two).to receive(:search_modules).with("puppetlabs").and_return([apache_2])
+
+                    result = multi_forge.search_modules("puppetlabs")
+
+                    expect(result.size).to eq 1
+                    expect(result.first["version"]).to eq "2"
+                end
+
+                it "combines the available tags" do
+                    apache_1 = { "author" => "puppetlabs", "full_name" => "puppetlabs/apache", "desc" => "one", "version" => "1", "tag_list" => ["a", "b"]}
+                    apache_2 = { "author" => "puppetlabs", "full_name" => "puppetlabs/apache", "desc" => "two", "version" => "2", "tag_list" => ["a", "c"]}
+                    expect(subforge_one).to receive(:search_modules).with("puppetlabs").and_return([apache_1])
+                    expect(subforge_two).to receive(:search_modules).with("puppetlabs").and_return([apache_2])
+
+                    result = multi_forge.search_modules("puppetlabs")
+
+                    tags = result.first["tag_list"]
+                    expect(tags).to eq ["a", "b", "c"]
+                end
+
+                it "combines the available versions, in order" do
+                    apache_3 = { "author" => "puppetlabs", "full_name" => "puppetlabs/apache", "desc" => "two", "version" => "3", "releases" => [{"version" => "3"}]}
+                    apache_1 = { "author" => "puppetlabs", "full_name" => "puppetlabs/apache", "desc" => "one", "version" => "1", "releases" => [{"version" => "1"}]}
+                    apache_2 = { "author" => "puppetlabs", "full_name" => "puppetlabs/apache", "desc" => "two", "version" => "2", "releases" => [{"version" => "2"}]}
+                    expect(subforge_one).to receive(:search_modules).with("puppetlabs").and_return([apache_1, apache_3])
+                    expect(subforge_two).to receive(:search_modules).with("puppetlabs").and_return([apache_2])
+
+                    result = multi_forge.search_modules("puppetlabs")
+
+                    tags = result.first["releases"]
+                    expect(tags).to eq [ {"version" => "3"}, {"version" => "2"}, {"version" => "1"} ]
+                end
+            end
+        end
+
+        describe "#get_module_buffer" do
+            context "when the module is found in a subforge" do
+                it "returns the module from the first subforge it's found in" do
+                    expect(subforge_one).to receive(:get_module_buffer).with("puppetlabs", "apache", "1.0.0").and_return("puppetlabs/apache module: 1.0.0")
+                    expect(subforge_two).not_to receive(:get_mo_bufferdule_buffer)
+
+                    mod = multi_forge.get_module_buffer("puppetlabs", "apache", "1.0.0")
+
+                    expect(mod).to eq "puppetlabs/apache module: 1.0.0"
+                end
+            end
+
+            context "when the module is not found in any subforge" do
+                it "raises an error" do
+                    expect(subforge_one).to receive(:get_module_buffer).with("puppetlabs", "nonexistant", "1.0.0").and_raise(ModuleNotFound)
+                    expect(subforge_two).to receive(:get_module_buffer).with("puppetlabs", "nonexistant", "1.0.0").and_raise(ModuleNotFound)
+
+                    expect {
+                        multi_forge.get_module_buffer("puppetlabs", "nonexistant", "1.0.0")
+                    }.to raise_exception(ModuleNotFound)
+                end
+            end
+        end
+
+        describe "#get_module_metadata" do
+            context "when versions of the module are found in subforges" do
+                it "combines the metadata" do
+                    apache_module_metadata_one = {
+                        "full_name" => "puppetlabs-apache", "releases" => [{"version"=>"1.0.0"}]
+                    }
+                    apache_module_metadata_two = {
+                        "full_name" => "puppetlabs-apache", "releases" => [{"version"=>"2.0.0"}]
+                    }
+                    expect(subforge_one).to receive(:get_module_metadata).with("puppetlabs", "apache").and_return(apache_module_metadata_one)
+                    expect(subforge_two).to receive(:get_module_metadata).with("puppetlabs", "apache").and_return(apache_module_metadata_two)
+
+                    metadata_list = multi_forge.get_module_metadata("puppetlabs", "apache")
+
+                    expect(metadata_list).to eq({
+                        "full_name" => "puppetlabs-apache",
+                        "releases" => [{"version"=>"1.0.0"}, {"version"=>"2.0.0"}]
+                    })
+                end
+            end
+
+            context "when no versions of the module are found in any subforge" do
+                it "raises an error" do
+                    expect(subforge_one).to receive(:get_module_metadata).with("puppetlabs", "apache").and_raise(ModuleNotFound)
+                    expect(subforge_two).to receive(:get_module_metadata).with("puppetlabs", "apache").and_raise(ModuleNotFound)
+
+                    expect {
+                        multi_forge.get_module_metadata("puppetlabs", "apache")
+                    }.to raise_exception(ModuleNotFound)
+                end
+            end
+
+            context "when the same version of a module is found in multiple forges" do
+                it "returns the one from the first forge it appears in" do
+                    apache_module_metadata_one = {
+                        "full_name" => "puppetlabs-apache", "releases" => [{"version"=>"1.0.0", "forge" => "one"}]
+                    }
+                    apache_module_metadata_two = {
+                        "full_name" => "puppetlabs-apache", "releases" => [{"version"=>"1.0.0", "forge" => "two"}]
+                    }
+                    expect(subforge_one).to receive(:get_module_metadata).with("puppetlabs", "apache").and_return(apache_module_metadata_one)
+                    expect(subforge_two).to receive(:get_module_metadata).with("puppetlabs", "apache").and_return(apache_module_metadata_two)
+
+                    metadata_list = multi_forge.get_module_metadata("puppetlabs", "apache")
+
+                    expect(metadata_list).to eq({
+                        "full_name" => "puppetlabs-apache",
+                        "releases" => [{"version"=>"1.0.0", "forge"=>"one"}]
+                    })
+                end
+            end
+        end
+
+        describe "#get_module_metadata_with_dependencies" do
+            context "when no versions of the module are found in any subforge" do
+                it "raises an error" do
+                    expect(subforge_one).to receive(:get_module_metadata_with_dependencies).with("puppetlabs", "apache", nil).and_raise(ModuleNotFound)
+                    expect(subforge_two).to receive(:get_module_metadata_with_dependencies).with("puppetlabs", "apache", nil).and_raise(ModuleNotFound)
+
+                    expect {
+                        multi_forge.get_module_metadata_with_dependencies("puppetlabs", "apache", nil)
+                    }.to raise_error(ModuleNotFound)
+                end
+            end
+
+            context "when versions of the module are found in subforges" do
+                it "a merged hash of the metadata" do
+                    base_metadata = {
+                        "puppetlabs/apache" => [ ],
+                        "puppetlabs/stdlib" => [
+                            {
+                                "version" => "2.4.0",
+                                "dependencies" => [ ]
+                            }
+                        ],
+                        "puppetlabs/concat" => [
+                            {
+                                "version" => "1.0.0",
+                                "dependencies" => [ ]
+                            }
+                        ]
+                    }
+                    apache_module_metadata_one = base_metadata.deep_clone.tap do |meta|
+                        meta["puppetlabs/apache"] << {
+                            "version" => "1",
+                            "dependencies" => [
+                                [ "puppetlabs/concat", ">= 1.0.0" ],
+                                [ "puppetlabs/stdlib", ">= 2.4.0" ]
+                            ]
+                        }
+                    end
+                    apache_module_metadata_two = base_metadata.deep_clone.tap do |meta|
+                        meta["puppetlabs/apache"] << {
+                            "version" => "2",
+                            "dependencies" => [
+                                [ "puppetlabs/concat", ">= 1.0.0" ],
+                                [ "puppetlabs/stdlib", ">= 2.4.0" ]
+                            ]
+                        }
+                    end
+                    expect(subforge_one).to receive(:get_module_metadata_with_dependencies).with("puppetlabs", "apache", nil).and_return(apache_module_metadata_one)
+                    expect(subforge_two).to receive(:get_module_metadata_with_dependencies).with("puppetlabs", "apache", nil).and_return(apache_module_metadata_two)
+
+                    metadata = multi_forge.get_module_metadata_with_dependencies("puppetlabs", "apache", nil)
+
+                    expect(metadata["puppetlabs/apache"]).to eq [
+                        {
+                            "version"=>"1",
+                            "dependencies"=> [["puppetlabs/concat", ">= 1.0.0"], ["puppetlabs/stdlib", ">= 2.4.0"]]
+                        },
+                        {
+                            "version"=>"2",
+                            "dependencies"=> [["puppetlabs/concat", ">= 1.0.0"], ["puppetlabs/stdlib", ">= 2.4.0"]]
+                        }
+                    ]
+                end
+            end
+
+            context "when the same version of a module is found in multiple forges" do
+                it "favors the one it finds first" do
+                    base_metadata = {
+                        "puppetlabs/apache" => [ ],
+                        "puppetlabs/stdlib" => [
+                            {
+                                "version" => "2.4.0",
+                                "dependencies" => [ ]
+                            }
+                        ],
+                        "puppetlabs/concat" => [
+                            {
+                                "version" => "1.0.0",
+                                "dependencies" => [ ]
+                            }
+                        ]
+                    }
+                    apache_module_metadata_one = base_metadata.deep_clone.tap do |meta|
+                        meta["puppetlabs/apache"] << {
+                            "version" => "1",
+                            "forge" => "1",
+                            "dependencies" => [
+                                [ "puppetlabs/concat", ">= 1.0.0" ],
+                                [ "puppetlabs/stdlib", ">= 2.4.0" ]
+                            ]
+                        }
+                    end
+                    apache_module_metadata_two = base_metadata.deep_clone.tap do |meta|
+                        meta["puppetlabs/apache"] << {
+                            "version" => "1",
+                            "forge" => "2",
+                            "dependencies" => [
+                                [ "puppetlabs/concat", ">= 1.0.0" ],
+                                [ "puppetlabs/stdlib", ">= 2.4.0" ]
+                            ]
+                        }
+                    end
+                    expect(subforge_one).to receive(:get_module_metadata_with_dependencies).with("puppetlabs", "apache", nil).and_return(apache_module_metadata_one)
+                    expect(subforge_two).to receive(:get_module_metadata_with_dependencies).with("puppetlabs", "apache", nil).and_return(apache_module_metadata_two)
+
+                    metadata = multi_forge.get_module_metadata_with_dependencies("puppetlabs", "apache", nil)
+
+                    expect(metadata["puppetlabs/apache"]).to eq [
+                        {
+                            "version"=>"1",
+                            "forge"=>"1",
+                            "dependencies"=> [["puppetlabs/concat", ">= 1.0.0"], ["puppetlabs/stdlib", ">= 2.4.0"]]
+                        },
+                    ]
+                end
+            end
+        end
+    end
+end

data/spec/forge/proxy_spec.rb

@@ -0,0 +1,206 @@
+# -*- encoding: utf-8 -*-
+# Puppet Library
+# Copyright (C) 2014 drrb
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'spec_helper'
+
+module PuppetLibrary::Forge
+    describe Proxy do
+        let(:http_client) { double('http_client') }
+        let(:query_cache) { PuppetLibrary::Http::Cache::InMemory.new }
+        let(:download_cache) { PuppetLibrary::Http::Cache::InMemory.new }
+        let(:forge) { Proxy.new("http://puppetforge.example.com", query_cache, download_cache, http_client) }
+
+        describe "url" do
+            it "defaults to HTTP, when protocol not specified" do
+                forge = Proxy.new("forge.puppetlabs.com", query_cache, download_cache, http_client) 
+
+                expect(http_client).to receive(:get).with("http:\/\/forge.puppetlabs.com/puppetlabs/apache.json").and_return('{"puppetlabs/apache":[]}')
+
+                forge.get_module_metadata("puppetlabs", "apache")
+            end
+
+            it "copes with a trailing slash" do
+                forge = Proxy.new("forge.puppetlabs.com/", query_cache, download_cache, http_client) 
+
+                expect(http_client).to receive(:get).with("http:\/\/forge.puppetlabs.com/puppetlabs/apache.json").and_return('{"puppetlabs/apache":[]}')
+
+                forge.get_module_metadata("puppetlabs", "apache")
+            end
+        end
+
+        describe "#search_modules" do
+            it "forwards the request directly" do
+                search_results = '["a","b","c"]'
+                expect(http_client).to receive(:get).
+                    with("http://puppetforge.example.com/modules.json?q=apache").
+                    and_return(search_results)
+
+                result = forge.search_modules("apache")
+                expect(result).to eq JSON.parse(search_results)
+            end
+
+            it "caches the results" do
+                search_results = '["a","b","c"]'
+                expect(http_client).to receive(:get).once.
+                    with("http://puppetforge.example.com/modules.json?q=apache").
+                    and_return(search_results)
+
+                forge.search_modules("apache")
+                forge.search_modules("apache")
+            end
+
+            context "when the query is nil" do
+                it "doesn't forward it as a request parameter" do
+                    expect(http_client).to receive(:get).
+                        with("http://puppetforge.example.com/modules.json").
+                        and_return("[]")
+
+                    forge.search_modules(nil)
+                end
+            end
+        end
+
+        describe "#get_module_buffer" do
+            context "module version not found" do
+                it "raises an error" do
+                    expect(http_client).to receive(:get).
+                        with("http://puppetforge.example.com/api/v1/releases.json?module=puppetlabs/apache").
+                        and_raise(OpenURI::HTTPError.new("404 Not Found", "Module not found"))
+
+                    expect {
+                        forge.get_module_buffer("puppetlabs", "apache", "1.0.0")
+                    }.to raise_error ModuleNotFound
+                end
+            end
+
+            context "when there is an error downloading the archive" do
+                it "raises an error" do
+                    expect(http_client).to receive(:get).
+                        with("http://puppetforge.example.com/api/v1/releases.json?module=puppetlabs/apache").
+                        and_return('{"puppetlabs/apache":[{"version":"1.0.0","file":"/puppetlabs/apache.tgz","dependencies":[["puppetlabs/concat",">= 1.0.0"],["puppetlabs/stdlib","~> 2.0.0"]]},{"version":"2.0.0","dependencies":[]}]}')
+                    expect(http_client).to receive(:download).
+                        with("http://puppetforge.example.com/puppetlabs/apache.tgz").
+                        and_raise(OpenURI::HTTPError.new("404 Not Found", "Module not found"))
+
+                    expect {
+                        forge.get_module_buffer("puppetlabs", "apache", "1.0.0")
+                    }.to raise_error ModuleNotFound
+                end
+            end
+
+            context "when the module is found" do
+                before do
+                    allow(http_client).to receive(:get).
+                        with("http://puppetforge.example.com/api/v1/releases.json?module=puppetlabs/apache").
+                        and_return('{"puppetlabs/apache":[{"version":"1.0.0","file":"/puppetlabs/apache.tgz","dependencies":[["puppetlabs/concat",">= 1.0.0"],["puppetlabs/stdlib","~> 2.0.0"]]},{"version":"2.0.0","dependencies":[]}]}')
+                end
+
+                it "returns a buffer containing the module archive" do
+                    file_buffer = "file buffer"
+                    expect(http_client).to receive(:download).
+                        with("http://puppetforge.example.com/puppetlabs/apache.tgz").
+                        and_return(file_buffer)
+
+                    result = forge.get_module_buffer("puppetlabs", "apache", "1.0.0")
+                    expect(result).to eq file_buffer
+                end
+
+                it "caches the download" do
+                    file_buffer = "file buffer"
+                    expect(http_client).to receive(:download).once.
+                        with("http://puppetforge.example.com/puppetlabs/apache.tgz").
+                        and_return(file_buffer)
+
+                    forge.get_module_buffer("puppetlabs", "apache", "1.0.0")
+                    forge.get_module_buffer("puppetlabs", "apache", "1.0.0")
+                end
+            end
+        end
+
+        describe "#get_module_metadata" do
+            context "when the module doesn't exist" do
+                it "raises an error" do
+                    expect(http_client).to receive(:get).
+                        with("http://puppetforge.example.com/puppetlabs/apache.json").
+                        and_raise(OpenURI::HTTPError.new("404 Not Found", "Module not found"))
+
+                    expect {
+                        forge.get_module_metadata("puppetlabs", "apache")
+                    }.to raise_error(ModuleNotFound)
+                end
+            end
+
+            context "when versions of the module exist" do
+                it "forwards the query directly" do
+                    response = '{"puppetlabs/apache":[{"version":"1.0.0","dependencies":[["puppetlabs/concat",">= 1.0.0"],["puppetlabs/stdlib","~> 2.0.0"]]},{"version":"2.0.0","dependencies":[]}]}'
+                    expect(http_client).to receive(:get).
+                        with("http://puppetforge.example.com/puppetlabs/apache.json").
+                        and_return(response)
+
+                    metadata = forge.get_module_metadata("puppetlabs", "apache")
+                    expect(metadata).to eq JSON.parse(response)
+                end
+
+                it "caches requests" do
+                    expect(http_client).to receive(:get).once.
+                        with("http://puppetforge.example.com/puppetlabs/apache.json").
+                        and_return('{}')
+
+                    forge.get_module_metadata("puppetlabs", "apache")
+                    forge.get_module_metadata("puppetlabs", "apache")
+                end
+            end
+        end
+
+        describe "#get_module_metadata_with_dependencies" do
+            context "the module isn't found" do
+                it "raises an error" do
+                    expect(http_client).to receive(:get).
+                        with("http://puppetforge.example.com/api/v1/releases.json?module=nonexistant/nonexistant").
+                        and_raise(OpenURI::HTTPError.new("410 Gone", "Module not found"))
+
+                    expect {
+                        forge.get_module_metadata_with_dependencies("nonexistant", "nonexistant", nil)
+                    }.to raise_error ModuleNotFound
+                end
+            end
+
+            context "when the module is found" do
+                it "forwards the request directly" do
+                    response = '{"puppetlabs/apache":[{"version":"1.0.0","dependencies":[["puppetlabs/concat",">= 1.0.0"],["puppetlabs/stdlib","~> 2.0.0"]]},{"version":"2.0.0","dependencies":[]}]}'
+                    expect(http_client).to receive(:get).
+                        with("http://puppetforge.example.com/api/v1/releases.json?module=puppetlabs/apache&version=1.0.0").
+                        and_return(response)
+
+                    result = forge.get_module_metadata_with_dependencies("puppetlabs", "apache", "1.0.0")
+
+                    expect(result).to eq JSON.parse(response)
+                end
+
+                it "caches the result" do
+                    response = '{"puppetlabs/apache":[{"version":"1.0.0","dependencies":[["puppetlabs/concat",">= 1.0.0"],["puppetlabs/stdlib","~> 2.0.0"]]},{"version":"2.0.0","dependencies":[]}]}'
+                    expect(http_client).to receive(:get).once.
+                        with("http://puppetforge.example.com/api/v1/releases.json?module=puppetlabs/apache&version=1.0.0").
+                        and_return(response)
+
+                    forge.get_module_metadata_with_dependencies("puppetlabs", "apache", "1.0.0")
+                    forge.get_module_metadata_with_dependencies("puppetlabs", "apache", "1.0.0")
+                end
+            end
+        end
+    end
+end

data/spec/puppet_library_spec.rb

@@ -19,14 +19,9 @@ require 'spec_helper'
 
 module PuppetLibrary
     describe PuppetLibrary do
-        let(:module_repo) do
-            module_repo = double(ModuleRepo::Multi)
-            allow(ModuleRepo::Multi).to receive(:new).and_return(module_repo)
-            return module_repo
-        end
         let(:forge) do
-            forge = double(Forge)
-            allow(Forge).to receive(:new).and_return(forge)
+            forge = double(Forge::Multi).as_null_object
+            allow(Forge::Multi).to receive(:new).and_return(forge)
             return forge
         end
         let(:server) do
@@ -91,13 +86,12 @@ module PuppetLibrary
             end
 
             context "when using --proxy option" do
-                it "adds a proxy module repository for each option specified" do
+                it "adds a proxy module forge for each option specified" do
                     proxy1 = double('proxy1')
                     proxy2 = double('proxy2')
-                    expect(ModuleRepo::Proxy).to receive(:new).with("http://forge1.example.com").and_return(proxy1)
-                    expect(ModuleRepo::Proxy).to receive(:new).with("http://forge2.example.com").and_return(proxy2)
-                    expect(Forge).to receive(:new).with(module_repo).and_return(forge)
-                    expect(module_repo).to receive(:add_repo).twice
+                    expect(Forge::Proxy).to receive(:new).with("http://forge1.example.com").and_return(proxy1)
+                    expect(Forge::Proxy).to receive(:new).with("http://forge2.example.com").and_return(proxy2)
+                    expect(forge).to receive(:add_forge).twice
                     expect(Rack::Server).to receive(:start).with(default_options)
 
                     library.go(["--proxy", "http://forge1.example.com", "--proxy", "http://forge2.example.com"])
@@ -105,14 +99,13 @@ module PuppetLibrary
             end
 
             context "when using --module-dir option" do
-                it "adds a module repository to the server for each module directory" do
-                    directory_repo_1 = double("directory_repo_1")
-                    directory_repo_2 = double("directory_repo_2")
-                    expect(ModuleRepo::Directory).to receive(:new).with("dir1").and_return(directory_repo_1)
-                    expect(ModuleRepo::Directory).to receive(:new).with("dir2").and_return(directory_repo_2)
-                    expect(Forge).to receive(:new).with(module_repo).and_return(forge)
-                    expect(module_repo).to receive(:add_repo).with(directory_repo_1)
-                    expect(module_repo).to receive(:add_repo).with(directory_repo_2)
+                it "adds a directory forge to the server for each module directory" do
+                    directory_forge_1 = double("directory_forge_1")
+                    directory_forge_2 = double("directory_forge_2")
+                    expect(Forge::Directory).to receive(:new).with("dir1").and_return(directory_forge_1)
+                    expect(Forge::Directory).to receive(:new).with("dir2").and_return(directory_forge_2)
+                    expect(forge).to receive(:add_forge).with(directory_forge_1)
+                    expect(forge).to receive(:add_forge).with(directory_forge_2)
                     expect(Rack::Server).to receive(:start).with(default_options)
 
                     library.go(["--module-dir", "dir1", "--module-dir", "dir2"])
@@ -122,9 +115,8 @@ module PuppetLibrary
             context "when no proxy URLs or module directories specified" do
                 it "proxies the Puppet Forge" do
                     proxy = double("proxy")
-                    expect(ModuleRepo::Proxy).to receive(:new).with("http://forge.puppetlabs.com").and_return(proxy)
-                    expect(Forge).to receive(:new).with(module_repo).and_return(forge)
-                    expect(module_repo).to receive(:add_repo).with(proxy)
+                    expect(Forge::Proxy).to receive(:new).with("http://forge.puppetlabs.com").and_return(proxy)
+                    expect(forge).to receive(:add_forge).with(proxy)
                     expect(Rack::Server).to receive(:start).with(default_options)
 
                     library.go([])
@@ -135,8 +127,8 @@ module PuppetLibrary
                 expect(log).to receive(:puts).with(/Port: default/)
                 expect(log).to receive(:puts).with(/Host: default/)
                 expect(log).to receive(:puts).with(/Server: default/)
-                expect(log).to receive(:puts).with(/Repositories:/)
-                expect(log).to receive(:puts).with(/- PuppetLibrary::ModuleRepo::Directory: \.\/modules/)
+                expect(log).to receive(:puts).with(/Forges:/)
+                expect(log).to receive(:puts).with(/- PuppetLibrary::Forge::Directory: \.\/modules/)
                 library.go(["--module-dir", "./modules"])
             end
         end

data/spec/server_spec.rb

@@ -28,6 +28,29 @@ module PuppetLibrary
             Server.new(forge)
         end
 
+        describe "GET /modules.json" do
+            it "renders the search result as JSON" do
+                search_results = [
+                    {
+                        "author" => "puppetlabs",
+                        "name" => "apache",
+                        "tag_list" => ["apache", "httpd"],
+                        "releases" => [{"version"=>"0.0.1"}, {"version"=>"0.0.2"}],
+                        "full_name" => "puppetlabs/apache",
+                        "version" => "0.0.2",
+                        "project_url" => "http://github.com/puppetlabs/puppetlabs-apache",
+                        "desc" => "Puppet module for Apache"
+                    }
+                ]
+                expect(forge).to receive(:search_modules).with("apache").and_return(search_results)
+
+                get "/modules.json?q=apache"
+
+                expect(last_response.body).to eq search_results.to_json
+                expect(last_response).to be_ok
+            end
+        end
+
         describe "GET /modules/<author>-<module>-<version>.tar.gz" do
             context "when the module is on the server" do
                 it "serves the module" do
@@ -45,7 +68,7 @@ module PuppetLibrary
 
             context "when the module is not on the server" do
                 it "returns an error" do
-                    expect(forge).to receive(:get_module_buffer).with("puppetlabs", "apache", "1.0.0").and_raise(ModuleNotFound)
+                    expect(forge).to receive(:get_module_buffer).with("puppetlabs", "apache", "1.0.0").and_raise(Forge::ModuleNotFound)
 
                     get "/modules/puppetlabs-apache-1.0.0.tar.gz"
 
@@ -77,7 +100,7 @@ module PuppetLibrary
 
             context "when no modules found" do
                 it "returns an error" do
-                    expect(forge).to receive(:get_module_metadata).with("nonexistant", "nonexistant").and_raise(ModuleNotFound)
+                    expect(forge).to receive(:get_module_metadata).with("nonexistant", "nonexistant").and_raise(Forge::ModuleNotFound)
 
                     get "/nonexistant/nonexistant.json"
 
@@ -125,7 +148,7 @@ module PuppetLibrary
 
             context "when the module can't be found" do
                 it "returns an error" do
-                    expect(forge).to receive(:get_module_metadata_with_dependencies).with("nonexistant", "nonexistant", nil).and_raise(ModuleNotFound)
+                    expect(forge).to receive(:get_module_metadata_with_dependencies).with("nonexistant", "nonexistant", nil).and_raise(Forge::ModuleNotFound)
 
                     get "/api/v1/releases.json?module=nonexistant/nonexistant"