mirage 3.0.13 → 3.0.14

data/spec/mirage/client/client_spec.rb

@@ -1,179 +0,0 @@
-require 'spec_helper'
-require 'mirage/client'
-
-describe Mirage::Client do
-
-
-  before :each do
-    @response = double('response').as_null_object
-  end
-
-  describe 'configuration' do
-    it 'is configured to connect to local host port 7001 by default' do
-      Client.new.url.should == "http://localhost:7001"
-    end
-
-    it 'can be configured with a url pointing to Mirage' do
-      mirage_url = "http://url.for.mirage"
-      Client.new(mirage_url).url.should == mirage_url
-
-      Client.new(:url => mirage_url).url.should == mirage_url
-    end
-
-    it 'can be configured with a port refering to which port Mirage is running on on localhost' do
-      port = 9001
-      Client.new(:port => port).url.should == "http://localhost:#{port}"
-    end
-
-    it 'raises an error if neither a port or url specified in the argument' do
-      expect { Client.new({}) }.to raise_error()
-      expect { Client.new("rubbish") }.to raise_error()
-    end
-
-
-    describe 'defaults' do
-      it 'can be configured with template defaults on initialize' do
-        templates, config = Templates.new("url"), proc {}
-        Templates.should_receive(:new).and_return(templates)
-        templates.should_receive(:default_config) do |&block|
-          block.should == config
-        end
-        Client.new &config
-      end
-
-      it 'can be configured with template defaults on after initalize' do
-        templates, config = Templates.new("url"), proc {}
-        Templates.should_receive(:new).and_return(templates)
-        templates.should_receive(:default_config) do |&block|
-          block.should == config
-        end
-        Client.new.configure &config
-      end
-
-      it 'can be reset' do
-        client = Client.new do
-          http_method :post
-        end
-
-        client.reset
-        client.templates.default_config.should == Template::Configuration.new
-      end
-
-    end
-  end
-
-  it 'should clear mirage' do
-    templates_mock = double('templates')
-    Templates.should_receive(:new).and_return(templates_mock)
-    templates_mock.should_receive(:delete_all)
-    Client.new.clear
-  end
-
-
-
-
-  it 'should prime mirage' do
-    Client.should_receive(:put) do |url|
-      url.should == "http://localhost:7001/defaults"
-    end
-    Client.new.prime
-  end
-
-  describe 'templates' do
-    it 'should give access to templates' do
-      mirage = Client.new
-      mirage.templates.instance_of?(Templates).should == true
-    end
-
-    it 'The templates instance should be the one created on construction otherwise the defaults passed in will get lost' do
-      mirage = Client.new
-      mirage.templates.should == mirage.templates
-    end
-
-    it 'should find a template' do
-      id = 1
-      mirage = Client.new
-      mock_template = double('template')
-      Template.should_receive(:get).with("#{mirage.url}/templates/#{id}").and_return(mock_template)
-      mirage.templates(1).should == mock_template
-    end
-
-
-    describe 'put' do
-      it "should put a response on mirage by passing args on to template's put method "  do
-        endpoint, value, block = 'greeting', 'hello', Proc.new{}
-
-        templates_mock = double('templates')
-        Templates.should_receive(:new).and_return(templates_mock)
-
-      templates_mock.should_receive(:put).with(endpoint, value, &block)
-
-        mirage = Client.new
-        mirage.put endpoint, value, &block
-      end
-    end
-  end
-
-  describe 'requests' do
-    it 'should give access to requests' do
-      mirage = Client.new
-      mirage.requests.instance_of?(Requests).should == true
-    end
-
-    it 'should find a request' do
-      id = 1
-      mirage = Client.new
-      Request.should_receive(:get).with("#{mirage.url}/requests/#{id}")
-      mirage.requests(id)
-    end
-  end
-
-  describe 'save' do
-    it 'should save the current template setup of mirage' do
-      mirage = Client.new
-      Client.should_receive(:put).with("#{mirage.url}/backup", :body => "")
-      mirage.save
-    end
-  end
-
-  describe 'revert' do
-    it 'should revert the current template set' do
-      mirage = Client.new
-      Client.should_receive(:put).with(mirage.url, :body => "")
-      mirage.revert
-    end
-  end
-
-  describe 'running?' do
-    it 'should check if mirage is runing' do
-      url = 'http://some_url'
-
-      Mirage.should_receive(:running?).with url
-      Client.new(url).running?
-    end
-  end
-
-
-  describe 'interface to mirage' do
-
-    after :each do
-      Mirage.stop
-    end
-
-    it 'should set a response' do
-      client = Mirage.start
-      response = client.templates.put("greeting", "hello")
-      response.id.should == 1
-    end
-
-    it 'should find mirage running' do
-      Mirage.start
-      Mirage.running?.should == true
-    end
-
-    it 'should not find mirage running' do
-      Mirage.running?.should == false
-    end
-
-  end
-end

data/spec/mirage/client/helpers/method_builder_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe Helpers::MethodBuilder do
-
-  describe 'a builder method' do
-    let :model do
-      model_class = Class.new do
-        extend Helpers::MethodBuilder
-
-        builder_method :name
-      end
-      model_class.new
-    end
-
-    context 'parameter is nil' do
-      it 'should set the value to nil' do
-        model.name(:joe)
-        model.name(nil)
-        expect(model.name).to be_nil
-      end
-    end
-
-    it 'should set a value' do
-      model.name(:joe)
-      model.name.should == :joe
-    end
-
-    it 'should chain' do
-      model.name(:joe).should == model
-    end
-
-    it 'should work with booleans' do
-      model.name(false)
-      model.name.should == false
-    end
-  end
-
-
-  it 'should let you define more than one builder method at a time' do
-    model_class = Class.new do
-      extend Helpers::MethodBuilder
-      builder_methods :foo, :bar
-    end
-    model = model_class.new
-    model.respond_to?(:foo).should be_true
-    model.respond_to?(:bar).should be_true
-  end
-end

data/spec/mirage/client/request_spec.rb

@@ -1,44 +0,0 @@
-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
-
-  it 'raises error when request is not found' do
-    Request.should_receive(:backedup_get).and_raise(StandardError)
-    
-    expect { Request.get(request_url) }.to raise_error(Request::NotReceivedException)
-  end
-end

data/spec/mirage/client/requests_spec.rb

@@ -1,9 +0,0 @@
-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/mirage/client/runner_spec.rb

@@ -1,138 +0,0 @@
-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/mirage/client/template/configuration_spec.rb

@@ -1,32 +0,0 @@
-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