puppet-library 0.0.2 → 0.1.0

data/spec/http/cache_spec.rb

@@ -0,0 +1,63 @@
+# -*- 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::Http
+    describe Cache do
+
+        let(:cache) { Cache.new }
+
+        describe "#get" do
+            context "the first time it's called" do
+                it "returns the value from the provided block" do
+                    greeting = cache.get("greeting") { "hello" }
+
+                    expect(greeting).to eq "hello"
+                end
+            end
+
+            context "the second time it's called" do
+                it "returns the cached value" do
+                    cache.get("greeting") { "hello" }
+                    greeting = cache.get("greeting") { "hi" }
+
+                    expect(greeting).to eq "hello"
+                end
+            end
+
+            context "when the cached value is falsey" do
+                it "returns the cached value" do
+                    cache.get("greeting") { false }
+                    greeting = cache.get("greeting") { true }
+
+                    expect(greeting).to be false
+                end
+            end
+
+            context "when the time limit has expired" do
+                it "looks up the value again" do
+                    cache = Cache.new(0)
+
+                    greeting = cache.get("greeting") { "hi" }
+                    greeting = cache.get("greeting") { "bye" }
+                    expect(greeting).to eq "bye"
+                end
+            end
+        end
+    end
+end

data/spec/http/http_client_spec.rb

@@ -0,0 +1,44 @@
+# -*- 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::Http
+    describe HttpClient do
+        let(:client) { HttpClient.new }
+
+        before do
+            allow(client).to receive(:open_uri).with("http:://example.com").and_return(StringIO.new("Content"))
+        end
+
+        describe "#get" do
+            it "calls open() on the provided URL and reads the result" do
+                content = client.get("http:://example.com")
+
+                expect(content).to eq "Content"
+            end
+        end
+
+        describe "#download" do
+            it "calls open() on the provided URL" do
+                content = client.download("http:://example.com")
+
+                expect(content.read).to eq "Content"
+            end
+        end
+    end
+end

data/spec/http/url_spec.rb

@@ -0,0 +1,39 @@
+# -*- 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::Http
+    describe Url do
+        describe "#normalize" do
+            it "leaves normal URLs alone" do
+                result = Url.normalize "http://localhost"
+                expect(result).to eq "http://localhost"
+            end
+
+            it "adds http:// to URI with no scheme" do
+                result = Url.normalize "localhost"
+                expect(result).to eq "http://localhost"
+            end
+
+            it "removes a trailing slash" do
+                result = Url.normalize "http://localhost/"
+                expect(result).to eq "http://localhost"
+            end
+        end
+    end
+end

data/spec/module_repo/directory_spec.rb

@@ -19,16 +19,18 @@ require 'spec_helper'
 module PuppetLibrary::ModuleRepo
     describe Directory do
         include ModuleSpecHelper
+        include FileUtils
 
-        let(:module_dir) { "/tmp/#{$$}" }
+        let(:module_dir) { Tempfile.new("module_dir").path }
         let(:module_repo) { Directory.new(module_dir) }
 
         before do
-            FileUtils.mkdir_p module_dir
+            rm_rf module_dir
+            mkdir_p module_dir
         end
 
         after do
-            FileUtils.rm_rf module_dir
+            rm_rf module_dir
         end
 
         describe "#get_module" do
@@ -71,8 +73,10 @@ module PuppetLibrary::ModuleRepo
                     metadata_list = module_repo.get_metadata("puppetlabs", "apache")
                     expect(metadata_list.size).to eq 2
                     metadata_list = metadata_list.sort_by {|m| m["version"] }
-                    expect(metadata_list[0]).to eq({ "name" => "puppetlabs-apache", "version" => "1.0.0" })
-                    expect(metadata_list[1]).to eq({ "name" => "puppetlabs-apache", "version" => "1.1.0" })
+                    expect(metadata_list[0]["name"]).to eq "puppetlabs-apache"
+                    expect(metadata_list[0]["version"]).to eq "1.0.0"
+                    expect(metadata_list[1]["name"]).to eq "puppetlabs-apache"
+                    expect(metadata_list[1]["version"]).to eq "1.1.0"
                 end
             end
         end

data/spec/module_repo/proxy_spec.rb

@@ -0,0 +1,105 @@
+# -*- 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::ModuleRepo
+    describe Proxy do
+        let(:http_client) { double('http_client') }
+        let(:repo) { Proxy.new("http://puppetforge.example.com", http_client) }
+
+        describe "url" do
+            it "defaults to HTTP, when protocol not specified" do
+                repo = Proxy.new("forge.puppetlabs.com", http_client)
+
+                expect(http_client).to receive(:get).with(/http:\/\/forge.puppetlabs.com/).and_return('{"puppetlabs/apache":[]}')
+
+                repo.get_metadata("puppetlabs", "apache")
+            end
+
+            it "copes with a trailing slash" do
+                repo = Proxy.new("forge.puppetlabs.com/", http_client)
+
+                expect(http_client).to receive(:get).with(/http:\/\/forge.puppetlabs.com\/api/).and_return('{"puppetlabs/apache":[]}')
+
+                repo.get_metadata("puppetlabs", "apache")
+            end
+        end
+
+        describe "#get_module" do
+            context "when the module exists" do
+                it "downloads the module" do
+                    expect(http_client).to receive(:get).
+                        with("http://puppetforge.example.com/api/v1/releases.json?module=puppetlabs/apache").
+                        and_return('{"puppetlabs/apache":[{"file":"/system/releases/p/puppetlabs/puppetlabs-apache-1.2.3.tar.gz","version":"1.2.3","dependencies":[]}]}')
+                    expect(http_client).to receive(:download).
+                        with("http://puppetforge.example.com/system/releases/p/puppetlabs/puppetlabs-apache-1.2.3.tar.gz").
+                        and_return("module buffer")
+
+                    module_buffer = repo.get_module("puppetlabs", "apache", "1.2.3")
+                    expect(module_buffer).to eq "module buffer"
+                end
+            end
+
+            context "when the module doesn't exist" do
+                it "returns nil" do
+                    expect(http_client).to receive(:get).
+                        with("http://puppetforge.example.com/api/v1/releases.json?module=puppetlabs/apache").
+                        and_return('{"puppetlabs/apache":[{"file":"/system/releases/p/puppetlabs/puppetlabs-apache-1.2.3.tar.gz","version":"1.2.3","dependencies":[]}]}')
+
+                    module_buffer = repo.get_module("puppetlabs", "apache", "9.9.9")
+                    expect(module_buffer).to be_nil
+                end
+            end
+        end
+
+        describe "#get_metadata" do
+            context "when the module doesn't exist" do
+                it "returns an empty array" 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"))
+
+                    metadata = repo.get_metadata("puppetlabs", "apache")
+                    expect(metadata).to be_empty
+                end
+            end
+
+            context "when versions of the module exist" do
+                it "returns an array of the versions" 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","dependencies":[["puppetlabs/concat",">= 1.0.0"],["puppetlabs/stdlib","~> 2.0.0"]]},{"version":"2.0.0","dependencies":[]}]}')
+
+                    metadata = repo.get_metadata("puppetlabs", "apache")
+                    expect(metadata.size).to eq 2
+                    expect(metadata.first).to eq({ "name" => "puppetlabs-apache", "author" => "puppetlabs", "version" => "1.0.0", "dependencies" => [{ "name" => "puppetlabs/concat", "version_requirement" => ">= 1.0.0" }, { "name" => "puppetlabs/stdlib", "version_requirement" => "~> 2.0.0" }] })
+                    expect(metadata.last).to eq({ "name" => "puppetlabs-apache", "author" => "puppetlabs", "version" => "2.0.0", "dependencies" => [] })
+                end
+
+                it "caches requests" do
+                    expect(http_client).to receive(:get).
+                        once.with("http://puppetforge.example.com/api/v1/releases.json?module=puppetlabs/apache").
+                        and_return('{"puppetlabs/apache":[{"version":"1.0.0","dependencies":[["puppetlabs/concat",">= 1.0.0"],["puppetlabs/stdlib","~> 2.0.0"]]},{"version":"2.0.0","dependencies":[]}]}')
+
+                    repo.get_metadata("puppetlabs", "apache")
+                    repo.get_metadata("puppetlabs", "apache")
+                end
+            end
+        end
+    end
+end

data/spec/module_spec_helper.rb

@@ -42,8 +42,10 @@ module ModuleSpecHelper
             archive.add_file("#{fqn}/metadata.json", 0644) do |file|
                 content = {
                     "name" => full_name,
-                    "version" => version
+                    "version" => version,
+                    "dependencies" => []
                 }
+                yield(content) if block_given?
                 file.write content.to_json
             end
         end

data/spec/puppet_library_spec.rb

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 # Puppet Library
-# Copyright (C) 2013 drrb
+# 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
@@ -24,14 +24,19 @@ module PuppetLibrary
             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)
+            return forge
+        end
         let(:server) do
             server = double(Server)
-            allow(Server).to receive(:new).and_return(server)
+            allow(Server).to receive(:new).with(forge).and_return(server)
             return server
         end
         let(:log) { double('log').as_null_object }
         let(:library) { PuppetLibrary.new(log) }
-        let(:default_options) {{ :app => server, :Host => "0.0.0.0", :Port => "9292"}}
+        let(:default_options) {{ :app => server, :Host => nil, :Port => nil, :server => nil }}
         before do
             allow(Rack::Server).to receive(:start)
         end
@@ -45,7 +50,7 @@ module PuppetLibrary
         end
 
         describe "#go" do
-            context "when specifying a bad option" do
+            context "when using a bad option" do
                 it "prints the usage" do
                     expect(log).to receive(:puts).with(/invalid option: --die\nUsage:/)
 
@@ -53,7 +58,7 @@ module PuppetLibrary
                 end
             end
 
-            context "when specifying no options" do
+            context "when using no options" do
                 it "runs the server with the default options" do
                     expect(Rack::Server).to receive(:start).with(default_options)
 
@@ -61,7 +66,7 @@ module PuppetLibrary
                 end
             end
 
-            context "when specifying --port option" do
+            context "when using --port option" do
                 it "runs the server with the specified port" do
                     expect(Rack::Server).to receive(:start).with(default_options_with(:Port => "8080"))
 
@@ -69,7 +74,15 @@ module PuppetLibrary
                 end
             end
 
-            context "when specifying --bind-host option" do
+            context "when using --server option" do
+                it "runs the app on the specified server" do
+                    expect(Rack::Server).to receive(:start).with(default_options_with(:server => "thin"))
+
+                    library.go(["--server", "thin"])
+                end
+            end
+
+            context "when using --bind-host option" do
                 it "runs the server with the specified bind host" do
                     expect(Rack::Server).to receive(:start).with(default_options_with(:Host => "localhost"))
 
@@ -77,18 +90,54 @@ module PuppetLibrary
                 end
             end
 
-            it "adds a module repository to the server for each module directory" do
-                expect(Server).to receive(:new).with(module_repo).and_return(server)
-                expect(module_repo).to receive(:add_repo).twice
-                expect(Rack::Server).to receive(:start).with(default_options)
+            context "when using --proxy option" do
+                it "adds a proxy module repository 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(Rack::Server).to receive(:start).with(default_options)
+
+                    library.go(["--proxy", "http://forge1.example.com", "--proxy", "http://forge2.example.com"])
+                end
+            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)
+                    expect(Rack::Server).to receive(:start).with(default_options)
+
+                    library.go(["--module-dir", "dir1", "--module-dir", "dir2"])
+                end
+            end
 
-                library.go(["--module-dir", "dir1", "--module-dir", "dir2"])
+            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(Rack::Server).to receive(:start).with(default_options)
+
+                    library.go([])
+                end
             end
 
             it "logs the server options" do
-                expect(log).to receive(:puts).with(/Port: 9292/)
-                expect(log).to receive(:puts).with(/Host: 0\.0\.0\.0/)
-                library.go([])
+                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/)
+                library.go(["--module-dir", "./modules"])
             end
         end
     end

data/spec/server_spec.rb

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 # Puppet Library
-# Copyright (C) 2013 drrb
+# 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
@@ -22,30 +22,17 @@ require 'rack/test'
 module PuppetLibrary
     describe Server do
         include Rack::Test::Methods
-        include ModuleSpecHelper
 
-        let(:module_dir) { "/tmp/#{$$}" }
-        let(:module_repo) { double(ModuleRepo) }
+        let(:forge) { double(Forge) }
         let(:app) do
-            Server.new(module_repo)
-        end
-
-        before do
-            FileUtils.mkdir_p module_dir
-        end
-
-        after do
-            FileUtils.rm_rf module_dir
+            Server.new(forge)
         end
 
         describe "GET /modules/<author>-<module>-<version>.tar.gz" do
             context "when the module is on the server" do
-                before do
-                    add_module("puppetlabs", "apache", "1.0.0")
-                end
                 it "serves the module" do
                     file_buffer = StringIO.new("module content")
-                    expect(module_repo).to receive(:get_module).with("puppetlabs", "apache", "1.0.0").and_return(file_buffer)
+                    expect(forge).to receive(:get_module_buffer).with("puppetlabs", "apache", "1.0.0").and_return(file_buffer)
 
                     get "/modules/puppetlabs-apache-1.0.0.tar.gz"
 
@@ -58,7 +45,7 @@ module PuppetLibrary
 
             context "when the module is not on the server" do
                 it "returns an error" do
-                    expect(module_repo).to receive(:get_module).with("puppetlabs", "apache", "1.0.0").and_return(nil)
+                    expect(forge).to receive(:get_module_buffer).with("puppetlabs", "apache", "1.0.0").and_raise(ModuleNotFound)
 
                     get "/modules/puppetlabs-apache-1.0.0.tar.gz"
 
@@ -70,32 +57,27 @@ module PuppetLibrary
 
         describe "GET /<author>/<module>.json" do
             it "gets module metadata for all versions" do
-                metadata = [ {
-                    "author" => "puppetlabs",
-                    "name" => "puppetlabs-apache",
-                    "description" => "Apache module",
-                    "version" => "1.0.0"
-                }, {
+                metadata = {
                     "author" => "puppetlabs",
-                    "name" => "puppetlabs-apache",
-                    "description" => "Apache module",
-                    "version" => "1.1.0"
-                } ]
-                expect(module_repo).to receive(:get_metadata).with("puppetlabs", "apache").and_return(metadata)
+                    "full_name" => "puppetlabs/apache",
+                    "name" => "apache",
+                    "desc" => "Puppet module for Apache",
+                    "releases" => [
+                        { "version" => "0.10.0" },
+                        { "version" => "0.9.0" },
+                    ]
+                }
+                expect(forge).to receive(:get_module_metadata).with("puppetlabs", "apache").and_return(metadata)
 
                 get "/puppetlabs/apache.json"
 
-                expect(last_response.body).to include('"author":"puppetlabs"')
-                expect(last_response.body).to include('"full_name":"puppetlabs/apache"')
-                expect(last_response.body).to include('"name":"apache"')
-                expect(last_response.body).to include('"desc":"Apache module"')
-                expect(last_response.body).to include('"releases":[{"version":"1.0.0"},{"version":"1.1.0"}]')
+                expect(last_response.body).to eq metadata.to_json
                 expect(last_response).to be_ok
             end
 
             context "when no modules found" do
                 it "returns an error" do
-                    expect(module_repo).to receive(:get_metadata).with("nonexistant", "nonexistant").and_return([])
+                    expect(forge).to receive(:get_module_metadata).with("nonexistant", "nonexistant").and_raise(ModuleNotFound)
 
                     get "/nonexistant/nonexistant.json"
 
@@ -107,57 +89,43 @@ module PuppetLibrary
 
         describe "GET /api/v1/releases.json" do
             it "gets metadata for module and dependencies" do
-                apache_metadata = [ {
-                    "author" => "puppetlabs",
-                    "name" => "puppetlabs-apache",
-                    "description" => "Apache module",
-                    "version" => "1.0.0",
-                    "dependencies" => [
-                        { "name" => "puppetlabs/stdlib", "version_requirement" => ">= 2.4.0" },
-                        { "name" => "puppetlabs/concat", "version_requirement" => ">= 1.0.0" }
-                    ]
-                }, {
-                    "author" => "puppetlabs",
-                    "name" => "puppetlabs-apache",
-                    "description" => "Apache module",
-                    "version" => "1.1.0",
-                    "dependencies" => [
-                        { "name" => "puppetlabs/stdlib", "version_requirement" => ">= 2.4.0" },
-                        { "name" => "puppetlabs/concat", "version_requirement" => ">= 1.0.0" }
+                metadata = {
+                    "puppetlabs/apache" => [
+                        {
+                            "file" => "/system/releases/p/puppetlabs/puppetlabs-apache-0.9.0.tar.gz",
+                            "version" => "0.9.0",
+                            "dependencies" => [
+                                [ "puppetlabs/concat", ">= 1.0.0" ],
+                                [ "puppetlabs/stdlib", ">= 2.4.0" ]
+                            ]
+                        }
+                    ],
+                    "puppetlabs/stdlib" => [
+                        {
+                            "file" => "/system/releases/p/puppetlabs/puppetlabs-stdlib-3.0.0.tar.gz",
+                            "version" => "3.0.0",
+                            "dependencies" => [ ]
+                        }
+                    ],
+                    "puppetlabs/concat" => [
+                        {
+                            "file" => "/system/releases/p/puppetlabs/puppetlabs-concat-1.0.0-rc1.tar.gz",
+                            "version" => "1.0.0-rc1",
+                            "dependencies" => [ ]
+                        }
                     ]
-                } ]
-                stdlib_metadata = [ {
-                    "author" => "puppetlabs",
-                    "name" => "puppetlabs-stdlib",
-                    "description" => "Stdlib module",
-                    "version" => "2.0.0",
-                    "dependencies" => [ ]
-                } ]
-                concat_metadata = [ {
-                    "author" => "puppetlabs",
-                    "name" => "puppetlabs-concat",
-                    "description" => "Concat module",
-                    "version" => "1.0.0",
-                    "dependencies" => [ ]
-                } ]
-                expect(module_repo).to receive(:get_metadata).with("puppetlabs", "apache").and_return(apache_metadata)
-                expect(module_repo).to receive(:get_metadata).with("puppetlabs", "stdlib").and_return(stdlib_metadata)
-                expect(module_repo).to receive(:get_metadata).with("puppetlabs", "concat").and_return(concat_metadata)
+                }
+                expect(forge).to receive(:get_module_metadata_with_dependencies).with("puppetlabs", "apache").and_return(metadata)
 
                 get "/api/v1/releases.json?module=puppetlabs/apache"
 
-                response = JSON.parse(last_response.body)
-                expect(response.keys.sort).to eq(["puppetlabs/apache", "puppetlabs/concat", "puppetlabs/stdlib"])
-                expect(response["puppetlabs/apache"].size).to eq(2)
-                expect(response["puppetlabs/apache"][0]["file"]).to eq("/modules/puppetlabs-apache-1.0.0.tar.gz")
-                expect(response["puppetlabs/apache"][0]["version"]).to eq("1.0.0")
-                expect(response["puppetlabs/apache"][0]["version"]).to eq("1.0.0")
+                expect(last_response.body).to eq metadata.to_json
                 expect(last_response).to be_ok
             end
 
             context "when the module can't be found" do
                 it "returns an error" do
-                    expect(module_repo).to receive(:get_metadata).with("nonexistant", "nonexistant").and_return([])
+                    expect(forge).to receive(:get_module_metadata_with_dependencies).with("nonexistant", "nonexistant").and_raise(ModuleNotFound)
 
                     get "/api/v1/releases.json?module=nonexistant/nonexistant"