mirage-on-thin 3.0.8

data/spec/client/request_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Request do
+  let(:id) { "url_for_request_entity" }
+  let(:request_url) { "requested_url" }
+  let(:trigger_url) { "trigger url" }
+
+  let(:body) { "body" }
+  let(:parameters) { {"name" => "joe"} }
+  let(:headers) { {"header" => "value"} }
+
+  let(:request_json) do
+    {body: body,
+     headers: headers,
+     parameters: parameters,
+     request_url: trigger_url,
+     id: id}
+  end
+
+  it 'delete a request' do
+    id = "url"
+    Request.should_receive(:delete).with(id)
+    request = Request.new
+    request.id = id
+    request.delete
+  end
+
+  it 'should load request data' do
+    Request.should_receive(:backedup_get).with(request_url, format: :json).and_return(request_json)
+
+    request = Request.get(request_url)
+    request.headers.should == headers
+    request.body.should == body
+    request.request_url.should == trigger_url
+    request.parameters.should == parameters
+    request.id.should == id
+  end
+
+end

data/spec/client/requests_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Requests do
+  it 'should delete all request data' do
+    base_url = "base_url"
+    Requests.should_receive(:delete).with("#{base_url}/requests")
+    Requests.new(base_url).delete_all
+  end
+end

data/spec/client/runner_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+require 'mirage/client'
+
+
+describe Mirage do
+
+  describe 'starting' do
+    before(:each) do
+      @runner = double
+      Runner.should_receive(:new).and_return(@runner)
+    end
+
+    it 'should start Mirage on port 7001 by default' do
+      @runner.should_receive(:invoke).with(:start, [], {:port => 7001})
+      client = Mirage.start
+      client.should == Mirage::Client.new
+    end
+
+    it 'should start mirage on the given port' do
+      options = {:port => 9001}
+      @runner.should_receive(:invoke).with(:start, [], options)
+      Mirage.start options
+    end
+  end
+
+  describe 'stopping' do
+    before(:each) do
+      @runner = double
+      Runner.stub(:new).and_return(@runner)
+    end
+
+    it 'should supply single port argument in an array to the runner' do
+      port = 7001
+      @runner.should_receive(:invoke).with(:stop, [], :port => [port])
+      @runner.should_receive(:invoke).with(:stop, [], :port => [:all])
+      Mirage.stop(:port => port)
+      Mirage.stop(:all)
+    end
+
+    it 'should stop multiple instances of Mirage' do
+      ports = 7001, 7002
+      @runner.should_receive(:invoke).with(:stop, [], :port => ports)
+      Mirage.stop(:port => ports)
+    end
+
+  end
+
+  describe Mirage::Runner do
+    it 'should stop the running instance of Mirage' do
+      options = {:port => []}
+      runner = Mirage::Runner.new
+      runner.options = options
+
+      runner.stub(:mirage_process_ids).with([]).and_return({"7001" => "18901"})
+
+
+      runner.should_receive(:kill).with("18901") do
+        RSpec.reset
+        runner.stub(:mirage_process_ids).with([]).and_return({})
+      end
+
+      Mirage::Runner.should_receive(:new).and_return(runner)
+      runner.invoke(:stop, [], options)
+    end
+
+    it 'should not stop any instances when more than one is running' do
+      options = {:port => []}
+      runner = Mirage::Runner.new
+      runner.options = options
+
+      runner.stub(:mirage_process_ids).with([]).and_return({"7001" => "18901", "7002" => "18902", "7003" => "18903"})
+      runner.should_not_receive(:kill)
+      Mirage::Runner.should_receive(:new).and_return(runner)
+
+      expect{ runner.invoke(:stop, [], options) }.to raise_error(Mirage::ClientError)
+    end
+
+
+    it 'should stop the instance running on the given port' do
+      options = {:port => [7001]}
+      runner = Mirage::Runner.new
+      runner.options = options
+
+      runner.should_receive(:mirage_process_ids).with([7001]).and_return({"7001" => "18901"})
+      runner.should_receive(:kill).with("18901") do
+        RSpec.reset
+        runner.stub(:mirage_process_ids).with([7001]).and_return({})
+      end
+
+      Mirage::Runner.should_receive(:new).and_return(runner)
+      runner.invoke(:stop, [], options)
+    end
+
+    it 'should stop the instance running on the given ports' do
+      options = {:port => [7001, 7002]}
+      runner = Mirage::Runner.new
+      runner.options = options
+
+      runner.should_receive(:mirage_process_ids).with([7001, 7002]).and_return({"7001" => "18901", "7002" => "18902"})
+      runner.should_receive(:kill).with("18901")
+      runner.should_receive(:kill).with("18902") do
+        RSpec.reset
+        runner.stub(:mirage_process_ids).with([7001, 7002]).and_return({})
+      end
+
+      Mirage::Runner.should_receive(:new).and_return(runner)
+      runner.invoke(:stop, [], options)
+    end
+
+    it 'should stop all running instances' do
+      options = {:port => [:all]}
+      runner = Mirage::Runner.new
+      runner.options = options
+
+      runner.should_receive(:mirage_process_ids).with([:all]).and_return({"7001" => "18901", "7002" => "18902"})
+      runner.should_receive(:kill).with("18901")
+      runner.should_receive(:kill).with("18902") do
+        RSpec.reset
+        runner.stub(:mirage_process_ids).with([:all]).and_return({})
+      end
+
+      Mirage::Runner.should_receive(:new).and_return(runner)
+      runner.invoke(:stop, [], options)
+
+    end
+
+    it 'should not error when asked to stop Mirage on a port that it is not running on' do
+      options = {:port => [7001]}
+      runner = Mirage::Runner.new
+      runner.options = options
+      runner.stub(:mirage_process_ids).with([7001]).and_return({})
+
+      Mirage::Runner.should_receive(:new).and_return(runner)
+      expect { runner.invoke(:stop, [], options) }.not_to raise_error
+    end
+
+  end
+end

data/spec/client/template/configuration_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'mirage/client'
+
+
+
+describe Template::Configuration do
+
+  it 'should have defaults' do
+    configuration = Template::Configuration.new
+    assert_defaults configuration
+  end
+
+  it 'should be reset' do
+    configuration = Template::Configuration.new
+    configuration.http_method :post
+    configuration.status 202
+    configuration.delay 3
+    configuration.default true
+    configuration.content_type "text/xml"
+
+    configuration.reset
+    assert_defaults configuration
+  end
+
+  def assert_defaults configuration
+    configuration.http_method.should == :get
+    configuration.status.should == 200
+    configuration.delay.should == 0
+    configuration.default.should == false
+    configuration.content_type.should == "text/plain"
+  end
+end

data/spec/client/template/model/common_methods_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+describe 'CommonMethods' do
+  let!(:model) do
+    Class.new do
+      include Template::Model::CommonMethods
+    end
+  end
+
+  let!(:instance) do
+    model.new
+  end
+  it 'should provide methods for customising the model' do
+    instance.methods.should include(:content_type,
+                                    :http_method,
+                                    :default,
+                                    :status,
+                                    :delay,
+                                    :required_parameters,
+                                    :required_body_content,
+                                    :required_headers,
+                                    :endpoint,
+                                    :headers,
+                                    :body)
+  end
+end

data/spec/client/template/model/instance_methods_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe Template::Model::InstanceMethods do
+
+
+  let!(:model) do
+    Class.new do
+      include Template::Model::InstanceMethods
+    end
+  end
+
+  let!(:instance) do
+    model.new '', ''
+  end
+
+
+  context 'initialize' do
+
+    it 'requires an endpoint' do
+      endpoint = 'value'
+      instance = model.new endpoint
+      instance.endpoint.should == endpoint
+    end
+
+    it 'requires an endpoint and value to be provided' do
+      endpoint, value = 'endpoint', 'value'
+      instance = model.new endpoint, value
+      instance.endpoint.should == endpoint
+      instance.body.should == value
+    end
+
+    it 'can use configuration for all http related config' do
+      config = Mirage::Template::Configuration.new
+      config.content_type 'content_type'
+      config.http_method 'method'
+      config.status 'status'
+      config.default true
+
+      instance = model.new 'endpoint', 'value', config
+      instance.content_type.should == config.content_type
+      instance.http_method.should == config.http_method
+      instance.status.should == config.status
+      instance.default.should == config.default
+
+      instance = model.new 'endpoint', config
+      instance.content_type.should == config.content_type
+      instance.http_method.should == config.http_method
+      instance.status.should == config.status
+      instance.default.should == config.default
+    end
+  end
+
+  context 'to_json' do
+    describe 'response body' do
+      it 'should base64 encode response values' do
+        value = "value"
+        response = model.new "endpoint", value
+        JSON.parse(response.to_json)["response"]["body"].should == Base64.encode64(value)
+      end
+    end
+
+    describe 'required request parameters' do
+
+      it 'should contain expected request parameters' do
+        required_parameters = {:key => "value"}
+        instance.required_parameters required_parameters
+        JSON.parse(instance.to_json)["request"]["parameters"].should == convert_keys_to_strings(required_parameters)
+      end
+
+      it 'should encode parameter requirements that are regexs' do
+        instance.required_parameters({:key => /regex/})
+        JSON.parse(instance.to_json)["request"]["parameters"].should == convert_keys_to_strings({:key => "%r{regex}"})
+      end
+    end
+
+    describe 'required body content' do
+      it 'should contain expected body content' do
+        required_body_content = ["body content"]
+        instance.required_body_content required_body_content
+        JSON.parse(instance.to_json)["request"]["body_content"].should == required_body_content
+      end
+
+      it 'should encode body content requirements that are regexs' do
+        instance.required_body_content [/regex/]
+        JSON.parse(instance.to_json)["request"]["body_content"].should == %w(%r{regex})
+      end
+    end
+
+    describe 'required headers' do
+      it 'should contain expected headers' do
+        required_headers = {:header => "value"}
+        instance.required_headers required_headers
+        JSON.parse(instance.to_json)["request"]["headers"].should == convert_keys_to_strings(required_headers)
+      end
+
+      it 'should encode header requirements that are regexs' do
+        instance.required_headers({:header => /regex/})
+        JSON.parse(instance.to_json)["request"]["headers"].should == convert_keys_to_strings(:header => "%r{regex}")
+      end
+    end
+
+    describe 'delay' do
+      it 'should default to 0' do
+        JSON.parse(instance.to_json)["response"]["delay"].should == 0
+      end
+
+      it 'should set the delay' do
+        delay = 5
+        instance.delay delay
+        JSON.parse(instance.to_json)["response"]["delay"].should == delay
+      end
+    end
+
+    describe 'status code' do
+      it 'should default to 200' do
+        JSON.parse(instance.to_json)["response"]["status"].should == 200
+      end
+
+      it 'should set the status' do
+        status = 404
+        instance.status status
+        JSON.parse(instance.to_json)["response"]["status"].should == status
+      end
+    end
+
+    describe 'http method' do
+      it 'should default to get' do
+        JSON.parse(instance.to_json)["request"]["http_method"].should == "get"
+      end
+
+      it 'should set the http method' do
+        method = :post
+        instance.http_method(method)
+        JSON.parse(instance.to_json)["request"]["http_method"].should == "post"
+      end
+    end
+
+    describe 'response as default' do
+      it 'should be false by default' do
+        JSON.parse(instance.to_json, symbolize_names: true)[:response][:default].should == false
+      end
+
+      it 'should set the default value' do
+        default = true
+        instance.default(default)
+        JSON.parse(instance.to_json)["response"]["default"].should == default
+      end
+    end
+
+    describe 'content type' do
+      it 'should be text/plain by default' do
+        JSON.parse(instance.to_json)["response"]["content_type"].should == "text/plain"
+      end
+
+      it 'should set the default value' do
+        content_type = "application/json"
+        instance.content_type content_type
+        JSON.parse(instance.to_json)["response"]["content_type"].should == content_type
+      end
+    end
+
+    it 'should set headers' do
+      header, value = 'header', 'value'
+      instance.headers[header] = value
+      JSON.parse(instance.to_json)["response"]["headers"].should == {header => value}
+    end
+  end
+
+end

data/spec/client/template/model_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe Template::Model do
+  let(:endpoint) { 'endpoint' }
+  let!(:test_class) do
+    Class.new do
+      extend Template::Model
+
+      endpoint 'endpoint'
+
+      def initialize
+        super
+      end
+    end
+  end
+  context 'class' do
+    it 'should extend MethodBuilder and CommonMethods' do
+      test_class.is_a?(Helpers::MethodBuilder).should == true
+      test_class.is_a?(Template::Model::CommonMethods).should == true
+    end
+
+    it 'should include Instance methods' do
+      test_class.is_a?(Template::Model::CommonMethods).should == true
+    end
+
+    context 'inherited constructor' do
+      it 'should set the endpoint of the class' do
+        test_class.new.endpoint.should == 'endpoint'
+      end
+
+      it 'calls to super should not fail if a constructor has been defined that takes args' do
+        test_class.class_eval do
+          def initialize arg
+            super
+          end
+        end
+        test_class.new('arg').endpoint.should == endpoint
+
+      end
+    end
+
+  end
+
+  context 'instances' do
+    it 'should have instance methods included' do
+      test_class.ancestors.should include(Template::Model::InstanceMethods)
+    end
+
+
+    it 'should include httparty' do
+      test_class.ancestors.should include(HTTParty)
+    end
+
+    describe 'defaults' do
+
+      it 'should be default the endpoint' do
+        endpoint = 'endpoint'
+        test_class.endpoint endpoint
+        test_class.new.endpoint.should == endpoint
+      end
+
+      it 'should be default the status' do
+        status = 404
+        test_class.status status
+        test_class.new.status.should == status
+      end
+
+      it 'should be default the content-type' do
+        content_type = 'application/json'
+        test_class.content_type content_type
+        test_class.new.content_type.should == content_type
+      end
+
+      it 'should be default the http_method' do
+        method = :post
+        test_class.http_method method
+        test_class.new.http_method.should == method
+      end
+
+      it 'should be default the default status' do
+        default = true
+        test_class.default default
+        test_class.new.default.should == default
+      end
+
+      it 'should be default the required parameters' do
+        required_parameters = {name: 'joe'}
+        test_class.required_parameters required_parameters
+        test_class.new.required_parameters.should == required_parameters
+      end
+
+      it 'should be default the required headers' do
+        headers = {name: 'joe'}
+        test_class.required_headers headers
+        test_class.new.required_headers.should == headers
+      end
+
+      it 'should be default the required body content' do
+        content = ['content']
+        test_class.required_body_content content
+        test_class.new.required_body_content.should == content
+      end
+
+      it 'should be default the headers' do
+        headers = {name: 'joe'}
+        test_class.headers headers
+        test_class.new.headers.should == headers
+      end
+
+      it 'should be default the delay' do
+        delay = 4
+        test_class.delay delay
+        test_class.new.delay.should == delay
+      end
+    end
+
+  end
+
+end