vidibus-service 0.0.1

data/lib/vidibus/service.rb

@@ -0,0 +1,15 @@
+module Vidibus # :nodoc
+  module Service # :nodoc
+    class Error < StandardError; end
+  end
+end
+
+require "service/client"
+require "service/mongoid"
+require "service/connector_app"
+require "service/controller_validations"
+
+# Shorthand for Service.discover
+def Service(wanted, realm)
+  Service.discover(wanted, realm)
+end

data/lib/vidibus-service.rb

@@ -0,0 +1,14 @@
+# require "rails"
+require "vidibus-secure"
+require "vidibus-validate_uri"
+require "vidibus-uuid"
+require "vidibus-core_extensions"
+
+$:.unshift(File.join(File.dirname(__FILE__), "vidibus"))
+require "service"
+
+if defined?(Rails)
+  module Vidibus::Service
+    class Engine < ::Rails::Engine; end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "rubygems"
+require "active_support/core_ext"
+require "rspec"
+require "rr"
+require "mongoid"
+require "webmock/rspec"
+
+require "vidibus-service"
+require "app/models/service"
+
+Mongoid.configure do |config|
+  name = "vidibus-service_test"
+  host = "localhost"
+  config.master = Mongo::Connection.new.db(name)
+  config.logger = nil
+end
+
+RSpec.configure do |config|
+  config.include WebMock
+  config.mock_with :rr
+  config.before(:each) do
+    Mongoid.master.collections.select {|c| c.name !~ /system/}.each(&:drop)
+  end
+end
+
+I18n.load_path += Dir[File.join('config', 'locales', '**', '*.{rb,yml}')]
+
+#ENV["VIDIBUS_SECURE_KEY"] = "c4l60HC/lyerr2VEnrP7s2YAldyZGfIBePUzCl+tBsTs1EWJOc8dEJ7F2Vty7KPEeRuBWGxZHVAbku8pLo+UvXRpLcRiF7lxKiKl"

data/spec/vidibus/service/client_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+describe Vidibus::Service::Client do
+  let(:this) {Service.create!(:function => "manager", :url => "http://manager.local", :uuid => "973a8710926e012d0a8c58b035f038ab", :secret => "EaDai5nz16DbQTWQuuFdd4WcAiZYRPDwZTn2IQeXbPE4yBg3rr", :this => true, :realm_uuid => nil)}
+  let(:uploader) {Service.create!(:function => "uploader", :url => "http://uploader.local", :uuid => "ddeb4500668e012d47bb58b035f038ab", :secret => "XaDai5nz1sDbQTWQuuFdd4WcAiZYRPDwZTn2IQeXbPE4yBg3rr", :realm_uuid => "e33f0d9093f9012d0dbc58b035f038ab")}
+  let(:client) { this; Vidibus::Service::Client.new(uploader) }
+
+  describe "#initialize" do
+    it "should require a service object" do
+      expect { Vidibus::Service::Client.new(:uploader) }.should raise_error(Vidibus::Service::Client::ServiceError)
+    end
+
+    it "should require this" do
+      expect { Vidibus::Service::Client.new(uploader) }.should raise_error(Service::ConfigurationError)
+    end
+
+    it "should set URL of given service as base_uri" do
+      this
+      client = Vidibus::Service::Client.new(uploader)
+      client.base_uri.should eql(uploader.url)
+    end
+  end
+
+  describe "#get" do
+    it "should load data via GET" do
+      stub_http_request(:get, "http://uploader.local/success").
+        with(:query => {:realm => uploader.realm_uuid, :service => this.uuid, :sign => "43a4d004c55113131f198c9772760467727b5564de74aacfcf4686751e3d388a"}).
+          to_return(:status => 200, :body => %({"hot":"stuff"}))
+      response = client.get("/success")
+      response.code.should eql(200)
+      response.should eql({"hot" => "stuff"})
+    end
+
+    it "should handle non-JSON responses" do
+      stub_http_request(:get, "http://uploader.local/success").
+        with(:query => {:realm => uploader.realm_uuid, :service => this.uuid, :sign => "43a4d004c55113131f198c9772760467727b5564de74aacfcf4686751e3d388a"}).
+          to_return(:status => 200, :body => "something")
+      response = client.get("/success")
+      response.code.should eql(200)
+      response.should eql("something")
+    end
+  end
+
+  describe "#post" do
+    it "should send data via POST" do
+      stub_http_request(:post, "http://uploader.local/create").
+        with(:body => {:some => "thing", :realm => uploader.realm_uuid, :service => this.uuid, :sign => "9c16bc080f106c73f28813f02899be97301b1b627d25a65d52f68a3c9732559d"}).
+          to_return(:status => 200)
+      response = client.post("/create", :body => {:some => "thing"})
+      response.code.should eql(200)
+    end
+  end
+
+  describe "#put" do
+    it "should send data via PUT" do
+      stub_http_request(:put, "http://uploader.local/update").
+        with(:body => {:some => "thing", :realm => uploader.realm_uuid, :service => this.uuid, :sign => "57e75433e49d9ef160b03b9e6a7d91fbd6523471eb8e7e36bb861066101f0903"}).
+          to_return(:status => 200)
+      response = client.put("/update", :body => {:some => "thing"})
+      response.code.should eql(200)
+    end
+  end
+
+  describe "#delete" do
+    it "should send a DELETE request" do
+      stub_http_request(:delete, "http://uploader.local/record/123").
+        with(:query => {:realm => uploader.realm_uuid, :service => this.uuid, :sign => "b9c026563d950a719e168c6f072f75c13f4843b82274f57f6e5a9a4cd8e0cc64"}).
+          to_return(:status => 200)
+      response = client.delete("/record/123")
+      response.code.should eql(200)
+    end
+  end
+end

data/spec/vidibus/service/connector_app_spec.rb

@@ -0,0 +1,246 @@
+require "spec_helper.rb"
+
+describe "Vidibus::Service::ConnectorApp" do
+  include Rack::Test::Methods
+
+  let(:this_params) { {"uuid" => "344b4b8088fb012dd3e558b035f038ab", "url" => "http://manager.local", "function" => "manager"} }
+  let(:connector_params) { {"uuid" => "60dfef509a8e012d599558b035f038ab", "url" => "https://connector.local"} }
+  let(:this) { Service.create!(this_params.merge(:secret => "EaDai5nz16DbQTWQuuFdd4WcAiZYRPDwZTn2IQeXbPE4yBg3rr", :realm_uuid => nil, :this => true)) }
+  let(:connector) { Service.create!(connector_params.merge(:function => "connector", :secret => nil, :realm_uuid => nil)) }
+
+  def app
+    @app ||= Vidibus::Service::ConnectorApp
+  end
+
+  # Sends a signed request.
+  def signed_request(method, url, params = nil)
+    self.send(method, *Vidibus::Secure.sign_request(method, url, params, this.secret))
+  end
+
+  it "should fail for request methods other than GET, POST, PUT, and DELETE" do
+    head "http://manager.local/connector"
+    last_response.status.should eql(400)
+  end
+
+  it "should fail for paths other than /connector" do
+    get "http://manager.local/something"
+    last_response.status.should eql(400)
+    last_response.body.should eql(%({"error":"This app must be configured to respond to /connector path."}))
+  end
+
+  describe "GET requests" do
+    it "should fail without signature" do
+      this and connector
+      get "http://manager.local/connector"
+      last_response.status.should eql(400)
+      last_response.body.should eql(%({"error":"Invalid signature."}))
+    end
+
+    it "should fail without valid signature" do
+      this and connector
+      get "http://manager.local/connector?sign=xxx"
+      last_response.status.should eql(400)
+      last_response.body.should eql(%({"error":"Invalid signature."}))
+    end
+
+    it "should fail without this service" do
+      connector
+      get "http://manager.local/connector"
+      last_response.status.should eql(400)
+    end
+
+    it "should return public data of this service as JSON" do
+      this
+      signed_request(:get, "http://manager.local/connector")
+      last_response.body.should eql({:this => this.public_data}.to_json)
+      last_response.status.should eql(200)
+      last_response.content_type.should eql("text/javascript; charset=utf-8")
+    end
+
+    it "should also return public data of connector as JSON, if a connector is given" do
+      this and connector
+      signed_request(:get, "http://manager.local/connector")
+      last_response.body.should eql({:this => this.public_data, :connector => connector.public_data}.to_json)
+      last_response.content_type.should eql("text/javascript; charset=utf-8")
+    end
+  end
+
+  describe "POST requests" do
+    it "should fail if this service has already been set up" do
+      this
+      post "http://manager/connector", {}
+      last_response.status.should eql(400)
+      last_response.body.should eql(%({"error":"Service has already been set up."}))
+    end
+
+    it "should require Connector params" do
+      post "http://manager.local/connector"
+      last_response.status.should eql(400)
+      last_response.body.should eql(%({"error":"No Connector data given."}))
+    end
+
+    it "should fail if Connector data is invalid" do
+      post "http://manager.local/connector", {:connector => {:some => "thing"}}
+      last_response.status.should eql(400)
+      last_response.body.should match("Setting up the Connector failed:")
+    end
+
+    it "should set up a Connector" do
+      mock(::Service).new(connector_params.merge(:function => "connector"))
+      expect {
+        post "http://manager.local/connector", {:connector => connector_params}
+      }.to raise_error(NoMethodError, "undefined method `save' for nil:NilClass")
+    end
+
+    context "with Connector or Connector params" do
+      before { connector }
+
+      it "should not require Connector params if a Connector is present" do
+        post "http://manager.local/connector"
+        last_response.body.should_not eql(%({"error":"No Connector data given."}))
+      end
+
+      it "should require params for this service" do
+        post "http://manager.local/connector"
+        last_response.status.should eql(400)
+        last_response.body.should eql(%({"error":"No data for this service given."}))
+      end
+
+      it "should fail if params for this service are invalid" do
+        post "http://manager.local/connector", {:this => {:some => "thing"}}
+        last_response.status.should eql(400)
+        last_response.body.should match("Setting up this service failed:")
+      end
+
+      it "should set up this Service" do
+        mock(::Service).new(this_params.merge(:this => true))
+        expect {
+          post "http://manager.local/connector", {:this => this_params}
+        }.to raise_error(NoMethodError, "undefined method `secret=' for nil:NilClass")
+      end
+
+      it "should request a secret for this Service" do
+        uri = "https://connector.local/services/#{this_params["uuid"]}/secret"
+        stub_http_request(:get, uri).to_return(:status => 200)
+        post "http://manager.local/connector", {:this => this_params}
+      end
+
+      it "should require a valid nonce to decrypt requested secret" do
+        uri = "https://connector.local/services/#{this_params["uuid"]}/secret"
+        params = {}
+        stub_http_request(:get, uri).to_return(:status => 200, :body => %({"secret":"something","sign":"else"}))
+        post "http://manager.local/connector", {:this => this_params.merge("nonce" => "invalid")}
+        last_response.status.should eql(400)
+        last_response.body.should match("Nonce is invalid.")
+      end
+
+      it "should decrypt requested secret and store it on the service object" do
+        nonce = "hkO2ssb28Gks19s9h2hdhbBs83hdis"
+        secret = "EaDai5nz16DbQTWQuuFdd4WcAiZYRPDwZTn2IQeXbPE4yBg3rr"
+        encrypted_secret = Vidibus::Secure.encrypt(secret, nonce)
+        signature = Vidibus::Secure.sign(encrypted_secret, nonce)
+        uri = "https://connector.local/services/#{this_params["uuid"]}/secret"
+        params = {:secret => encrypted_secret, :sign => signature}
+        stub_http_request(:get, uri).to_return(:status => 200, :body => params.to_json)
+        post "http://manager.local/connector", {:this => this_params.merge("nonce" => nonce)}
+        last_response.status.should eql(201)
+        this = ::Service.where(:this => true).first
+        this.should be_a(::Service)
+        this.secret.should eql(secret)
+      end
+    end
+  end
+
+  describe "PUT requests" do
+    it "should fail without signature" do
+      this and connector
+      put "http://manager.local/connector"
+      last_response.status.should eql(400)
+      last_response.body.should eql(%({"error":"Invalid signature."}))
+    end
+
+    it "should fail without valid signature" do
+      this and connector
+      put "http://manager.local/connector?sign=xxx"
+      last_response.status.should eql(400)
+      last_response.body.should eql(%({"error":"Invalid signature."}))
+    end
+
+    it "should succeed with valid signature" do
+      this and connector
+      signed_request(:put, "http://manager.local/connector")
+      last_response.status.should eql(200)
+    end
+
+    it "should fail if this service is unconfigured" do
+      get "http://manager.local/connector?sign=jkasdnkajdb"
+      last_response.status.should eql(400)
+    end
+
+    it "should update existing services" do
+      this and connector
+      url = "http://newconnector.local"
+      signed_request(:put, "http://manager.local/connector", {:connector => {:url => url}})
+      last_response.status.should eql(200)
+      Service.local(:connector).url.should eql(url)
+    end
+
+    it "should fail if invalid data are given" do
+      this and connector
+      url = "http://newconnector.local"
+      signed_request(:put, "http://manager.local/connector", {:connector => {:secret => "not allowed"}})
+      last_response.status.should eql(400)
+      last_response.body.should match("Updating connector failed:")
+    end
+
+    it "should create new services" do
+      this and connector
+      url = "http://newconnector.local"
+      signed_request(:put, "http://manager.local/connector",
+        {:uploader => {:url => "http://uploader.local", :uuid => "c0861d609247012d0a8b58b035f038ab", :secret => "A7q8Vzxgrk9xrw2FCnvV4bv01UP/LBUUM0lIGDmMcB2GsBTIqx", :realm_uuid => "12ab69f099a4012d4df558b035f038ab"}})
+      last_response.status.should eql(200)
+      Service.local(:uploader, "12ab69f099a4012d4df558b035f038ab").url.should eql("http://uploader.local")
+    end
+  end
+
+  describe "DELETE requests" do
+    it "should fail without signature" do
+      this and connector
+      delete "http://manager.local/connector"
+      last_response.status.should eql(400)
+      last_response.body.should eql(%({"error":"Invalid signature."}))
+    end
+
+    it "should fail without valid signature" do
+      this and connector
+      delete "http://manager.local/connector?sign=xxx"
+      last_response.status.should eql(400)
+      last_response.body.should eql(%({"error":"Invalid signature."}))
+    end
+
+    it "should fail if this service is unconfigured" do
+      delete "http://manager.local/connector?sign=jkasdnkajdb"
+      last_response.status.should eql(400)
+    end
+
+    it "should fail if list of UUIDs is not given" do
+      this and connector
+      signed_request(:delete, "http://manager.local/connector", {})
+      last_response.status.should eql(400)
+      last_response.body.should eql(%({"error":"Provide list of :uuids"}))
+    end
+
+    it "should delete services given by UUID" do
+      this and connector
+      signed_request(:delete, "http://manager.local/connector", {:uuids =>["60dfef509a8e012d599558b035f038ab"]})
+      last_response.status.should eql(200)
+      Service.local(:connector).should be_nil
+    end
+
+    it "should not care if any given UUID is invalid" do
+      this and connector
+      signed_request(:delete, "http://manager.local/connector", {:uuids =>["invalid", "60dfef509a8e012d599558b035f038ab"]})
+      last_response.status.should eql(200)
+    end
+  end
+end

data/spec/vidibus/service/controller_validations_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe "Vidibus::Service::ControllerValidations" do
+  it "should be spec'd"
+end

data/spec/vidibus/service/mongoid_spec.rb

@@ -0,0 +1,226 @@
+require "spec_helper"
+
+describe "Vidibus::Service::Mongoid" do
+  let(:realm) { "12ab69f099a4012d4df558b035f038ab" }
+  let(:this) { Service.create!(:function => "manager", :url => "http://manager.local", :uuid => "344b4b8088fb012dd3e558b035f038ab", :secret => "EaDai5nz16DbQTWQuuFdd4WcAiZYRPDwZTn2IQeXbPE4yBg3rr", :realm_uuid => nil, :this => true) }
+  let(:connector) { Service.create!(:function => "connector", :url => "http://connector.local", :uuid => "60dfef509a8e012d599558b035f038ab", :secret => nil, :realm_uuid => nil) }
+  let(:uploader) { Service.create!(:function => "uploader", :url => "http://uploader.local", :uuid => "c0861d609247012d0a8b58b035f038ab", :secret => "A7q8Vzxgrk9xrw2FCnvV4bv01UP/LBUUM0lIGDmMcB2GsBTIqx", :realm_uuid => realm) }
+  let(:client_mock) { this; mock.any_instance_of(Vidibus::Service::Client) }
+
+  describe "validation" do
+    it "should pass with valid attributes" do
+      this.should be_valid
+    end
+
+    it "should fail without a valid URL" do
+      this.url = "something"
+      this.should be_invalid
+    end
+
+    it "should fail without a function" do
+      this.function = ""
+      this.should be_invalid
+      this.errors[:function].should have(1).error
+    end
+
+    it "should pass with arbitrary functions" do
+      this.function = :something
+      this.should be_valid
+    end
+
+    it "should fail if a secret is given for Connector" do
+      connector.secret = "something"
+      connector.should be_invalid
+      connector.errors[:secret].should have(1).error
+      connector.errors[:secret].first.should eql("is not allowed for a Connector")
+    end
+
+    it "should pass with empty secret for Connector" do
+      connector.secret = nil
+      connector.should be_valid
+    end
+
+    it "should fail without a secret for services except Connector" do
+      uploader.secret = nil
+      uploader.should be_invalid
+      uploader.errors[:secret].should have(1).error
+    end
+
+    it "should fail without a realm_uuid for services except Connector and this" do
+      uploader.realm_uuid = nil
+      uploader.should be_invalid
+      uploader.errors[:realm_uuid].should have(1).error
+    end
+
+    it "should pass with empty realm_uuid for Connector" do
+      connector.realm_uuid = nil
+      connector.should be_valid
+    end
+
+    it "should pass if realm_uuid is given for Connector" do
+      connector.realm_uuid = realm
+      connector.should be_valid
+    end
+
+    it "should pass if a realm_uuid is given for this" do
+      this.realm_uuid = realm
+      this.should be_valid
+    end
+
+    it "should fail for duplicate UUIDs within same realm" do
+      duplicate_service = Service.new(:uuid => uploader.uuid, :realm_uuid => realm)
+      duplicate_service.should be_invalid
+      duplicate_service.errors[:uuid].should have(1).error
+    end
+  end
+
+  describe "#url" do
+    it "should be set without trailing slash" do
+      this.url = "http://manager.local/"
+      this.url.should eql("http://manager.local")
+    end
+
+    it "should be stored without trailing slash" do
+      this.update_attributes(:url => "http://manager.local/")
+      this.reload.url.should eql("http://manager.local")
+    end
+  end
+
+  describe "#domain" do
+    it "should return the url without protocol" do
+      this.domain.should eql(this.url.gsub(/https?:\/\//, ""))
+    end
+  end
+
+  describe "#connector?" do
+    it "should return true if service is a Connector" do
+      connector.connector?.should be_true
+    end
+
+    it "should return false if service is not a Connector" do
+      uploader.connector?.should be_false
+    end
+  end
+
+  describe "#get" do
+    it "should trigger a GET request" do
+      client_mock.get("/something", :query => { :gotta => "give" })
+      uploader.get("/something", :query => { :gotta => "give" })
+    end
+  end
+
+  describe "#post" do
+    it "should trigger a POST request" do
+      client_mock.post("/something", :query => { :do => "it" })
+      uploader.post("/something", :query => { :do => "it" })
+    end
+  end
+
+  describe "#put" do
+    it "should trigger a PUT request" do
+      client_mock.put("/something", :query => { :new => "stuff" })
+      uploader.put("/something", :query => { :new => "stuff" })
+    end
+  end
+
+  describe "#delete" do
+    it "should trigger a DELETE request" do
+      client_mock.delete("/something/else", {})
+      uploader.delete("/something/else")
+    end
+  end
+
+  describe ".this" do
+    it "should return this service" do
+      this
+      Service.this.should eql(this)
+    end
+
+    it "should raise an error if this service has not been configured yet" do
+      expect {Service.this}.to raise_error(Service::ConfigurationError)
+    end
+  end
+
+  describe ".connector" do
+    it "should return the Connector" do
+      connector
+      Service.connector.should eql(connector)
+    end
+
+    it "should raise an error if the Connector has not been configured yet" do
+      expect {Service.connector}.to raise_error(Service::ConfigurationError)
+    end
+  end
+
+  describe ".local" do
+    before {uploader}
+
+    it "should return a service matching given function without a realm" do
+      connector
+      Service.local(:connector).should eql(connector)
+    end
+
+    it "should return a service matching given function and realm" do
+      Service.local(:uploader, realm).should eql(uploader)
+    end
+
+    it "should return no service if it does not match given realm" do
+      Service.local(:uploader).should be_nil
+    end
+
+    it "should return no service if it does not match given function" do
+      Service.local(:connector, realm).should be_nil
+    end
+
+    it "should return a service matching given UUID and realm" do
+      Service.local(uploader.uuid, realm).should eql(uploader)
+    end
+
+    it "should return no service if it does not match given function" do
+      Service.local("123", realm).should be_nil
+    end
+  end
+
+  describe ".discover" do
+    it "should first try to find a local service" do
+      uploader
+      mock(Service).local(:uploader, realm) {uploader}
+      dont_allow(Service).remote(:uploader, realm)
+      Service.discover(:uploader, realm).should eql(uploader)
+    end
+
+    it "if no local service can be found a remote one should be fetched" do
+      mock(Service).local(:uploader, realm) {nil}
+      mock(Service).remote(:uploader, realm) {uploader}
+      Service.discover(:uploader, realm).should eql(uploader)
+    end
+  end
+
+  describe ".remote" do
+    it "should require a realm" do
+      expect {Service.remote(:uploader, nil)}.to raise_error(ArgumentError)
+    end
+
+    it "should fetch service data from Connector and create a local service object" do
+      connector and this
+      stub_http_request(:get, "http://connector.local/services/uploader").
+        with(:query => {:realm => "12ab69f099a4012d4df558b035f038ab", :service => "344b4b8088fb012dd3e558b035f038ab", :sign => "d27be37e9440765d38789f9000a5b3a86c741b3954c88f7b1769e4067ac9fbd0"}).
+         to_return(:status => 200, :body => %({"uuid":"c0861d609247012d0a8b58b035f038ab", "url":"http://uploader.local", "function":"uploader", "secret":"kjO8AjgX68Yp7OQ1XF8dTfPBE5GCuCnd/OPko+A9yCaw8qnj9xoyMGZEXQpf\niVBOUcux1qlW8hfT6UPKGoVfYA==\n"}))
+      Service.remote(:uploader, realm)
+
+      uploader = Service.local(:uploader, realm)
+      uploader.uuid.should eql("c0861d609247012d0a8b58b035f038ab")
+      uploader.function.should eql("uploader")
+      uploader.url.should eql("http://uploader.local")
+      uploader.secret.should eql(Vidibus::Secure.decrypt("kjO8AjgX68Yp7OQ1XF8dTfPBE5GCuCnd/OPko+A9yCaw8qnj9xoyMGZEXQpf\niVBOUcux1qlW8hfT6UPKGoVfYA==\n", this.secret))
+    end
+
+    it "should raise an error requested service has already been stored" do
+      connector and this and uploader
+      stub_http_request(:get, "http://connector.local/services/uploader").
+        with(:query => {:realm => "e75234809111012d05ac58b035f038ab", :service => "973a8710926e012d0a8c58b035f038ab", :sign => "a93d3a1a0124e969f97d68feab37638ec8737b1d8ddc582cd204fbb228ad7e2b"}).
+         to_return(:status => 200, :body => %({"uuid":"c0861d609247012d0a8b58b035f038ab", "url":"http://uploader.local", "function":"uploader", "secret":"kjO8AjgX68Yp7OQ1XF8dTfPBE5GCuCnd/OPko+A9yCaw8qnj9xoyMGZEXQpf\niVBOUcux1qlW8hfT6UPKGoVfYA==\n"}))
+      expect { Service.remote(:uploader, realm) }.to raise_error
+    end
+  end
+end

data/spec/vidibus/service_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe "Vidibus::Service::Error" do
+  it "should be derived from StandardError" do
+    Vidibus::Service::Error.superclass.should eql(StandardError)
+  end
+end
+
+describe "Service" do
+  it "should be a shorthand for Service.discover" do
+    mock(Service).discover(:uploader, "realm")
+    Service(:uploader, "realm")
+  end
+end