mirage-on-thin 3.0.8

data/lib/mirage/client/error.rb

@@ -0,0 +1,22 @@
+module Mirage
+  class MirageError < ::Exception
+    attr_reader :code
+
+    def initialize message, code
+      super message
+      @code = message, code
+    end
+  end
+
+  class InternalServerException < MirageError
+  end
+
+  class TemplateNotFound < ::Exception
+  end
+
+  class ClientError < ::Exception
+    def initialize message
+      super message
+    end
+  end
+end

data/lib/mirage/client/helpers/method_builder.rb

@@ -0,0 +1,19 @@
+module Mirage
+  module Helpers
+    module MethodBuilder
+      def builder_methods *method_names
+
+        method_names.each do |method_name|
+          method_name = method_name.to_sym
+          define_method method_name do |arg=nil|
+            return instance_variable_get("@#{method_name}".to_sym) if arg.nil?
+            instance_variable_set("@#{method_name}".to_sym, arg)
+            self
+          end
+        end
+
+      end
+      alias builder_method builder_methods
+    end
+  end
+end

data/lib/mirage/client/request.rb

@@ -0,0 +1,26 @@
+require 'hashie/mash'
+module Mirage
+  class Request
+    include HTTParty
+
+    class << self
+      alias_method :backedup_get, :get
+      def get url
+        result = Hashie::Mash.new(backedup_get(url, format: :json))
+        request = new
+        request.parameters = result.parameters
+        request.headers = result.headers
+        request.request_url = result.request_url
+        request.body = result.body
+        request.id = result.id
+        request
+      end
+    end
+
+    attr_accessor :parameters, :headers, :body, :request_url, :id
+
+    def delete
+      self.class.delete(id)
+    end
+  end
+end

data/lib/mirage/client/requests.rb

@@ -0,0 +1,13 @@
+module Mirage
+  class Requests
+    include HTTParty
+
+    def initialize base_url
+      @url = "#{base_url}/requests"
+    end
+
+    def delete_all
+      self.class.delete(@url)
+    end
+  end
+end

data/lib/mirage/client/runner.rb

@@ -0,0 +1,103 @@
+require 'thor'
+require 'waitforit'
+require 'childprocess'
+require 'uri'
+require 'httparty'
+module Mirage
+  class << self
+
+    # Start Mirage locally on a given port
+    # Example Usage:
+    #
+    #   Mirage.start :port => 9001 -> Configured MirageClient ready to use.
+    def start options={}
+      options={:port => 7001}.merge(options)
+      Runner.new.invoke(:start, [], options)
+      Mirage::Client.new(options)
+    end
+
+    # Stop locally running instance(s) of Mirage
+    #
+    # Example Usage:
+    #   Mirage.stop -> Will stop mirage if there is only instance running. Can be running on any port.
+    #   Mirage.stop :port => port -> stop mirage on a given port
+    #   Mirage.stop :port => [port1, port2...] -> stops multiple running instances of Mirage
+    def stop options={:port => []}
+      options = {:port => :all} if options == :all
+
+      if options[:port]
+        options[:port] = [options[:port]] unless options[:port].is_a?(Array)
+      end
+
+      Runner.new.invoke(:stop, [], options)
+    rescue ClientError => e
+      raise ClientError.new("Mirage is running multiple ports, please specify the port(s) see api/tests for details")
+    end
+
+
+    # Detect if Mirage is running on a URL or a local port
+    #
+    # Example Usage:
+    #   Mirage.running? -> boolean indicating whether Mirage is running on *locally* on port 7001
+    #   Mirage.running? :port => port -> boolean indicating whether Mirage is running on *locally* on the given port
+    #   Mirage.running? url -> boolean indicating whether Mirage is running on the given URL
+    def running? options_or_url = {:port => 7001}
+      url = options_or_url.kind_of?(Hash) ? "http://localhost:#{options_or_url[:port]}" : options_or_url
+      HTTParty.get(url) and return true
+    rescue Errno::ECONNREFUSED
+      return false
+    end
+
+  end
+
+  class Runner < Thor
+    include CLIBridge
+    RUBY_CMD = ChildProcess.jruby? ? 'jruby' : 'ruby'
+
+    desc "start", "Starts mirage"
+    method_option :port, :aliases => "-p", :type => :numeric, :default => 7001, :desc => "port that mirage should be started on"
+    method_option :defaults, :aliases => "-d", :type => :string, :default => 'mirage', :desc => "location to load default responses from"
+    method_option :debug, :type => :boolean, :default => false, :desc => "run in debug mode"
+
+    def start
+      port = options[:port]
+      process_ids = mirage_process_ids([port])
+      unless process_ids.empty?
+        warn "Mirage is already running: #{process_ids.values.join(",")}"
+        return
+      end
+
+      mirage_server_file = "#{File.dirname(__FILE__)}/../../../mirage_server.rb"
+
+      if ChildProcess.windows?
+        command = ["cmd", "/C", "start", "mirage server port #{port}", RUBY_CMD, mirage_server_file]
+      else
+        command = [RUBY_CMD, mirage_server_file]
+      end
+
+
+      command = command.concat(options.to_a).flatten.collect { |arg| arg.to_s }
+      ChildProcess.build(*command).start
+
+      wait_until(:timeout_after => 30.seconds) { Mirage.running?(options) }
+
+      begin
+        Mirage::Client.new(options).prime
+      rescue Mirage::InternalServerException => e
+        puts "WARN: #{e.message}"
+      end
+    end
+
+    desc "stop", "Stops mirage"
+    method_option :port, :aliases => "-p", :type => :array, :default => [], :banner => "[port_1 port_2|all]", :desc => "port(s) of mirage instance(s). ALL stops all running instances"
+
+    def stop
+      ports = options[:port].collect{|port| port=~/\d+/ ? port.to_i : port}
+      process_ids = mirage_process_ids(ports)
+      raise ClientError.new("Mirage is running on ports #{process_ids.keys.sort.join(", ")}. Please run mirage stop -p [PORT(s)] instead") if (process_ids.size > 1 && ports.empty?)
+      process_ids.values.each { |process_id| kill process_id }
+      wait_until { mirage_process_ids(options[:port]).empty? }
+    end
+
+  end
+end

data/lib/mirage/client/template.rb

@@ -0,0 +1,56 @@
+require 'ostruct'
+require 'json'
+require 'httparty'
+require 'hashie/mash'
+
+require 'client/template/configuration'
+require 'client/template/model'
+
+module Mirage
+
+  class Template
+
+    include HTTParty
+    include Model::InstanceMethods
+    include Model::CommonMethods
+
+    class << self
+      alias_method :backedup_get, :get
+
+      def get url
+        response = backedup_get(url, :format => :json)
+        raise TemplateNotFound if response.code == 404
+        response_hashie = Hashie::Mash.new response
+
+        response_config = response_hashie.response
+        request_config = response_hashie.request
+
+        template = new(response_hashie.endpoint, Base64.decode64(response_config.body))
+
+        template.id response_hashie.id
+        template.default response_config['default']
+        template.delay response_config.delay
+        template.content_type response_config.content_type
+        template.status response_config.status
+        template.headers response_config.headers
+
+        template.required_parameters request_config.parameters
+        template.required_body_content request_config.body_content
+        template.http_method request_config.http_method
+        template.url url
+        template.requests_url response_hashie.requests_url
+        template.required_headers request_config.headers
+
+        template
+      end
+    end
+
+    def initialize *args
+      endpoint = args.first
+
+      raise ArgumentError, "You must specify a string endpoint as the first argument" unless endpoint && endpoint.is_a?(String)
+      super *args
+
+    end
+  end
+end

data/lib/mirage/client/template/configuration.rb

@@ -0,0 +1,44 @@
+require 'client/helpers/method_builder'
+
+module Mirage
+  class Template
+    class Configuration
+      extend Helpers::MethodBuilder
+      builder_methods :http_method, :status, :delay, :content_type, :default
+      attr_accessor :caller_binding
+      DEFAULT_HTTP_METHOD=:get
+      DEFAULT_STATUS=200
+      DEFAULT_DELAY=0
+      DEFAULT_CONTENT_TYPE="text/plain"
+      DEFAULT_DEFAULT=false
+
+      def initialize
+        reset
+      end
+
+      def reset
+        @http_method = DEFAULT_HTTP_METHOD
+        @status = DEFAULT_STATUS
+        @delay = DEFAULT_DELAY
+        @content_type = DEFAULT_CONTENT_TYPE
+        @default = DEFAULT_DEFAULT
+      end
+
+
+      def method_missing(method, *args, &block)
+        @caller_binding.send method, *args, &block if @caller_binding
+      end
+
+      def == config
+        config.is_a?(Configuration) &&
+            http_method == config.http_method &&
+            status == config.status &&
+            delay == config.delay &&
+            content_type == config.content_type &&
+            default == config.default
+
+      end
+
+    end
+  end
+end

data/lib/mirage/client/template/model.rb

@@ -0,0 +1,48 @@
+require 'client/helpers/method_builder'
+require 'client/template/model/common_methods'
+require 'client/template/model/instance_methods'
+
+module Mirage
+  class Template
+    module Model
+
+      class << self
+        def extended clazz
+          clazz.extend(CommonMethods)
+          clazz.extend(Helpers::MethodBuilder)
+          clazz.send(:include, HTTParty)
+          clazz.send(:include, CommonMethods)
+          clazz.send(:include, InstanceMethods)
+
+
+          mod = Module.new do
+            def initialize *args
+
+              super *args
+              [:content_type,
+               :http_method,
+               :default,
+               :status,
+               :delay,
+               :required_parameters,
+               :required_body_content,
+               :required_headers,
+               :headers,
+               :endpoint, :delay].each do |attribute|
+                eval("#{attribute} self.class.#{attribute} if self.class.#{attribute}")
+              end
+
+
+            end
+          end
+
+          clazz.send(:include, mod)
+
+          clazz.format :json
+          clazz
+        end
+      end
+    end
+
+  end
+end

data/lib/mirage/client/template/model/common_methods.rb

@@ -0,0 +1,24 @@
+module Mirage
+
+  class Template
+    module Model
+      module CommonMethods
+        extend Helpers::MethodBuilder
+
+        builder_methods :content_type,
+                        :http_method,
+                        :default,
+                        :status,
+                        :delay,
+                        :required_parameters,
+                        :required_body_content,
+                        :required_headers,
+                        :headers,
+                        :endpoint,
+                        :body
+      end
+
+    end
+  end
+
+end

data/lib/mirage/client/template/model/instance_methods.rb

@@ -0,0 +1,95 @@
+module Mirage
+  class Template
+    module Model
+      module InstanceMethods
+        extend Helpers::MethodBuilder
+        include CommonMethods
+
+        attr_accessor :caller_binding
+
+        def initialize *args
+          if args.last.is_a?(Template::Configuration)
+            default_config = args.delete_at(-1)
+          else
+            default_config = Template::Configuration.new
+          end
+
+          @endpoint, @body = *args
+          @content_type = default_config.content_type
+          @http_method = default_config.http_method
+          @status = default_config.status
+          @delay = default_config.delay
+          @required_parameters = {}
+          @required_headers = {}
+          @required_body_content = []
+          @headers = {}
+          @default = default_config.default
+        end
+
+        builder_method :id,
+                       :url,
+                       :requests_url
+
+
+        def create
+          @id = self.class.put("#{@endpoint}", :body => self.to_json, :headers => {'content-type' => 'application/json'})['id']
+          self
+        end
+
+        def delete
+          self.class.delete(url)
+          Request.delete requests_url
+        end
+
+
+        def to_json
+          {
+              :response => {
+                  :body => Base64.encode64(body),
+                  :status => status,
+                  :default => default,
+                  :content_type => content_type,
+                  :headers => headers,
+                  :delay => delay
+              },
+              :request => {
+                  :parameters => encode_regexs(required_parameters),
+                  :headers => encode_regexs(required_headers),
+                  :body_content => encode_regexs(required_body_content),
+                  :http_method => http_method,
+              }
+          }.to_json
+        end
+
+
+        def encode_regexs hash_or_array
+          case hash_or_array
+            when Array
+              hash_or_array.collect { |value| encode(value) }
+            else
+              encoded = {}
+              hash_or_array.each do |key, value|
+                encoded[key] = encode(value)
+              end
+              encoded
+          end
+        end
+
+        def encode(value)
+          value.is_a?(Regexp) ? "%r{#{value.source}}" : value
+        end
+
+        def method_missing(method, *args, &block)
+
+          if @caller_binding
+            @caller_binding.send method, *args, &block
+          else
+            super method, *args, &block
+          end
+
+        end
+      end
+
+    end
+  end
+end