mirage 3.0.13 → 3.0.14

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

@@ -1,25 +0,0 @@
-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/mirage/client/template/model/instance_methods_spec.rb

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

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

data/spec/mirage/client/template_spec.rb

@@ -1,146 +0,0 @@
-require 'spec_helper'
-require 'mirage/client'
-
-
-describe Mirage::Template do
-
-  describe 'get' do
-    it 'should load a template given its id' do
-      endpoint = "endpoint"
-      id = 1
-      requests_url = 'request_url'
-      body = "Hello"
-      default = true
-      delay = 1.2
-      content_type = "application/json"
-      status = 201
-      headers = {'header' => 'value'}
-
-
-      required_parameters = {"name" => 'joe'}
-      required_body_content = %{content}
-      required_headers = {"header" => 'value'}
-      http_method = "get"
-
-      template_json = {
-          endpoint: endpoint,
-          id: id,
-          requests_url: requests_url,
-          response:{
-              default: default,
-              body: Base64.encode64(body),
-              delay: delay,
-              content_type: content_type,
-              status: status,
-              headers: headers
-          },
-          request: {
-              parameters: required_parameters,
-              body_content: required_body_content,
-              headers: required_headers,
-              http_method: http_method
-          }
-      }
-      template_json.should_receive(:code).and_return 200
-
-      template_url = "url"
-      Template.should_receive(:backedup_get).with(template_url, :format => :json).and_return(template_json)
-
-      template = Template.get(template_url)
-      template.body.should == body
-      template.endpoint.should == endpoint
-      template.id.should == id
-
-      template.default.should == default
-      template.delay.should == delay
-      template.content_type.should == content_type
-      template.status.should == status
-      template.headers.should == headers
-
-      template.required_parameters.should  == required_parameters
-      template.required_body_content.should == required_body_content
-      template.required_headers.should  == required_headers
-      template.http_method.should == http_method
-      template.url.should  == template_url
-      template.requests_url.should == requests_url
-    end
-
-    it 'should raise an error if the template is not found' do
-      template_url = 'url'
-      response = double(code: 404)
-      Template.should_receive(:backedup_get).with(template_url, :format => :json).and_return response
-      expect{Template.get(template_url)}.to raise_error Mirage::TemplateNotFound
-    end
-  end
-
-  describe 'initialize' do
-    it 'throws and exception if an endpoint is not supplied as the first parameter' do
-      expect{Template.new}.to raise_error(ArgumentError)
-    end
-
-    it 'throws and exception if first argument is not a string' do
-      expect{Template.new(:endpoint)}.to raise_error(ArgumentError)
-    end
-  end
-
-
-  describe 'creating' do
-    json = "reponse json"
-    endpoint = "greeting"
-
-    it 'should create a template on mirage' do
-      template = Template.new(endpoint,json)
-
-      template.should_receive(:to_json).and_return(json)
-      Template.should_receive(:put).with(endpoint, :body => json, :headers => {'content-type' => 'application/json'}).and_return(convert_keys_to_strings({:id => 1}))
-      template.create
-      template.id.should == 1
-    end
-
-    it 'should have default values set' do
-      template = Template.new(endpoint,json)
-      template.http_method.should == :get
-      template.status.should == 200
-      template.content_type.should == "text/plain"
-      template.default.should == false
-      template.delay.should == 0
-    end
-  end
-
-
-  describe 'deleting' do
-
-    it 'should clear a response' do
-      id = 1
-      template_url = "base_url/templates/#{id}"
-      request_url = "base_url/requests/#{id}"
-
-      template = Template.new("", "")
-      template.url template_url
-      template.requests_url request_url
-
-
-      template.stub(:id).and_return(id)
-
-      Template.should_receive(:delete).with(template_url)
-
-      Mirage::Request.should_receive(:delete).with(request_url)
-      template.delete
-    end
-
-  end
-
-  describe 'method missing' do
-    it 'should delagate to the caller if it is set' do
-      caller = Object.new
-      caller.should_receive(:some_method)
-      template = Template.new('endpoint')
-      template.caller_binding = caller
-      template.some_method
-    end
-
-    it 'should throw a standard method missing error if a caller binding is not set' do
-      expect{Template.new('endpoint').some_method}.to raise_error(NameError)
-    end
-  end
-end