hover-ruby-client 0.3.1

data/test/unit/client/hover_test.rb

@@ -0,0 +1,62 @@
+require './test/test_helper'
+
+require 'hover/client/hover'
+
+describe Hover::Client::Hover do
+  let(:client) { Hover::Client::Hover.new('access_id', 'secret_key') }
+  
+  it "inits" do
+    assert client.is_a?(Hover::Client::Hover)
+  end
+  
+  it "json_get" do
+    arguments = ['orders.json', {}]
+    
+    response = mock
+    parsed_response = mock
+    client.expects(:get).with(*arguments).returns(response)
+    client.expects(:parse_response).with(response).returns(parsed_response)
+    
+    client.json_get(*arguments).must_equal(parsed_response)
+  end
+  
+  it "json_put" do
+    arguments = ['orders/1.json', {'order[address]' => 'kansas'}]
+    
+    response = mock
+    parsed_response = mock
+    client.expects(:put).with(*arguments).returns(response)
+    client.expects(:parse_response).with(response).returns(parsed_response)
+    
+    client.json_put(*arguments).must_equal(parsed_response)
+  end
+  
+  it "json_post" do
+    response = mock
+    parsed_response = mock
+    client.expects(:post).with('orders.json', {'order[address]' => 'elsewhere'}).returns(response)
+    client.expects(:parse_response).with(response).returns(parsed_response)
+    
+    client.json_post('orders.json', {'order[address]' => 'elsewhere'}).must_equal(parsed_response)
+  end
+  
+  it "json_patch" do
+    arguments = ['orders/1.json', {'order[address]' => 'san francisco'}]
+    
+    response = mock
+    parsed_response = mock
+    client.expects(:patch).with(*arguments).returns(response)
+    client.expects(:parse_response).with(response).returns(parsed_response)
+    
+    client.json_patch(*arguments).must_equal(parsed_response)
+  end
+  
+  it "json_delete" do
+    response = mock
+    parsed_response = mock
+    client.expects(:delete).with('orders/1.json').returns(response)
+    client.expects(:parse_response).with(response).returns(parsed_response)
+    
+    client.json_delete('orders/1.json').must_equal(parsed_response)
+  end
+end

data/test/unit/client/manowar_test.rb

@@ -0,0 +1,34 @@
+require './test/test_helper'
+
+require 'hover/client/manowar'
+
+describe Hover::Client::Manowar do
+  before do
+    @client = Hover::Client::Manowar.new('access_id', 'secret_key')
+  end
+  
+  it "inits" do
+    assert @client.is_a?(Hover::Client::Manowar)
+  end
+  
+  describe "submit_order" do
+    it "submits" do
+      parameters = {
+        "order[midas_identifier]" => 1,
+        "order[images_attributes][0][id]" => 1,
+        "order[images_attributes][1][id]" => 2
+      }
+      
+      @client.expects(:json_post).with("orders.json", parameters)
+      
+      @client.submit_order(parameters)
+    end
+  end
+  
+  describe "order_results" do
+    it "gets results" do
+      @client.expects(:json_get).with("orders/1/results.json")
+      @client.order_results(1)
+    end
+  end
+end

data/test/unit/client/midas_test.rb

@@ -0,0 +1,187 @@
+require './test/test_helper'
+
+require 'hover/client/midas'
+
+describe Hover::Client::Midas do
+  before do
+    @client = Hover::Client::Midas.new('access_id', 'secret_key', 'http://localhost:3000')
+  end
+  
+  it "inits" do
+    assert @client.is_a?(Hover::Client::Midas)
+  end
+  
+  describe "user" do
+    it "gets user info" do
+      @client.expects(:json_get).with("me.json")
+      @client.me
+    end
+  end
+  
+  describe "orders" do
+    
+    describe "index" do
+      it "gets index" do
+        @client.expects(:json_get).with("orders.json", {})
+        @client.orders
+      end
+      
+      it "gets second page of index" do
+        @client.expects(:json_get).with("orders.json", {page: 2})
+        @client.orders(page: 2)
+      end
+    end
+    
+    describe "show" do
+      it "shows" do
+        @client.expects(:json_get).with("orders/1.json", {})
+        @client.order(1)
+      end
+    end
+    
+    describe "create" do
+      it "creates" do
+        @client.expects(:json_post).with("orders.json", {})
+        @client.create_order
+      end
+    end
+    
+    describe "complete upload" do
+      it "completes" do
+        @client.expects(:patch).with("orders/1/archive_uploading_complete.json")
+        @client.complete_order_upload(1)
+      end
+    end
+    
+    describe "complete work" do
+      it "completes" do
+        @client.expects(:put).with("orders/1/work_complete.json")
+        @client.order_complete_work(1)
+      end
+    end
+  end
+  
+  describe "images" do
+    describe "index" do
+      it "gets index" do
+        @client.expects(:json_get).with("images.json", {})
+        @client.images
+      end
+      
+      it "gets second page of index" do
+        @client.expects(:json_get).with("images.json", {page: 2})
+        @client.images(page: 2)
+      end
+      
+      it "gets images for order" do
+        @client.expects(:json_get).with("images.json", {order_id: 1})
+        @client.images(order_id: 1)
+      end
+    end
+    
+    describe "show" do
+      it "shows" do
+        @client.expects(:json_get).with("images/1.json")
+        @client.image(1)
+      end
+    end
+    
+    describe "download_image" do
+      before do
+        @client.expects(:get_redirect_location).with("images/1.jpg", {}).once.returns("http://example.com/usr/to/s3")
+      end
+      
+      it "contains the correct contents" do
+        chunk = "testing 1 2 3"
+        uri_mock = mock
+        uri_mock.expects(:read).once.returns(chunk)
+        Kernel.expects(:open).once.returns(uri_mock)
+        
+        @client.download_image({"id" => 1}) do |file|
+          file.read.must_equal(chunk)
+          file.must_be_kind_of(File)
+          File.exist?(file.path).must_equal(true)
+        end
+      end
+    end
+    
+    describe "upload_image" do
+      it "uploads" do
+        file = File.new("/tmp/test", "w")
+        
+        image = {
+          "id" => 1,
+          "image" => {"upload_url" => "http://localhost/v1/images.json"}
+        }
+        
+        file = mock
+        file.expects(:size).returns(1).once
+        
+        request = mock
+        request.expects(:body_stream=).with(file).once
+        request.expects(:content_length=).with(1).once
+        
+        request.expects(:[]=).with('Content-Type', '') # otherwise the signature is invalid!
+        
+        Net::HTTP::Put.expects(:new)
+          .with(URI.parse(image["image"]["upload_url"]).request_uri)
+          .returns(request)
+          .once
+        
+        Net::HTTP.any_instance.expects(:use_ssl=).with(true).once
+        Net::HTTP.any_instance.expects(:request).with(request).once
+        
+        @client.upload_image(image, file)
+      end
+      
+    end
+    
+    describe "upload images for order" do
+      it "fails if there are too many images" do
+        collection = [{"id" => 1}]
+        file_name_list = %w(1.jpg 2.jpg 3.jpg 4.jpg)
+        
+        Dir.expects(:glob).once.returns(file_name_list)
+        
+        @client.expects(:json_get).with("images/upload_urls.json", order_id: 1).returns(collection)
+        @client.expects(:upload_image).never
+        
+        Proc.new {
+          @client.upload_images_for_order(1, "/tmp/testing_upload_images_for_order")
+        }.must_raise RuntimeError
+      end
+      
+      it "uploads images for order" do
+        collection = (1 .. 5).inject([]) { |a, n| a << {"id" => n} }
+        file_name_list = %w(1.jpg 2.jpg 3.jpg 4.jpg)
+        
+        Dir.expects(:glob).once.returns(file_name_list)
+        
+        @client.expects(:json_get).with("images/upload_urls.json", order_id: 1).returns(collection)
+        @client.expects(:upload_image).at_most(file_name_list.size).at_least(file_name_list.size)
+        
+        @client.upload_images_for_order(1, "/tmp/testing_upload_images_for_order")
+      end
+    end
+    
+    describe "upload prometheus export" do
+      it "uploads export" do
+        path = File.join(File.dirname(__FILE__), '..', '..', 'files', 'archive.zip')
+        
+        Zip::Entry.any_instance.expects(:extract).twice
+        @client.expects(:upload_images_for_order).once
+        
+        @client.upload_images_from_prometheus_export(1, path)
+      end
+    end
+    
+    describe "upload_image_urls" do
+      it "requests urls" do
+        @client.expects(:json_get).with("images/upload_urls.json", order_id: 1).once
+        @client.image_upload_urls(1)
+      end
+    end
+    
+  end
+  
+end

data/test/unit/client/static_test.rb

@@ -0,0 +1,169 @@
+require './test/test_helper'
+
+require 'hover/client/static'
+
+describe Hover::Client::Static do
+  let(:application) { 'hyperion' }
+  let(:environment) { 'development' }
+
+  before do
+    @client = Hover::Client::Static.new(application, environment, 'access_id', 'secret_key')
+  end
+
+  it "inits" do
+    assert @client.is_a?(Hover::Client::Static)
+  end
+
+  describe "param_name" do
+    it "metric value" do
+      Hover::Client::Static.param_name('metric', 'value').must_equal('metric[value]')
+    end
+
+    it "metric tags->order->practice" do
+      Hover::Client::Static.param_name('metric', 'tags', 'order', 'practice').must_equal('metric[tags][order][practice]')
+    end
+
+    it "tags order->practice" do
+      Hover::Client::Static.param_name('tags', 'order', 'practice').must_equal('tags[order][practice]')
+    end
+  end
+
+  describe "tags_to_parameter" do
+    it "flat hash" do
+      input = {
+        modeler: 'yanis@hover.to',
+        server: 'production',
+        order: 1234
+      }
+
+      output = {
+        'metric[tags][modeler]' => 'yanis@hover.to',
+        'metric[tags][server]' => 'production',
+        'metric[tags][order]' => 1234
+      }
+
+      Hover::Client::Static.tags_to_params(input).must_equal(output)
+    end
+
+    it "nested" do
+      input = {
+        a: 1,
+        b: 2,
+        c: {
+          d: 4,
+          e: ['a', 'b', 'c']
+        },
+      }
+
+      output = {
+        'metric[tags][a]' => 1,
+        'metric[tags][b]' => 2,
+        'metric[tags][c][d]' => 4,
+        'metric[tags][c][e][]' => ['a', 'b', 'c']
+      }
+
+      Hover::Client::Static.tags_to_params(input).must_equal(output)
+    end
+  end
+
+  describe "metrics" do
+    describe "create" do
+      let(:happened_at) { Time.now.utc }
+
+      it "reports to alooma" do
+        @client.expects(:alooma_url).returns("https://localhost").at_least(1)
+
+        http = mock
+        Net::HTTP.expects(:new).returns(http)
+        http.expects(:use_ssl=).with(true)
+        response = mock
+        response.expects(:code).returns(200)
+        http.expects(:request).returns(response)
+
+        @client.create_metric(name: 'foo', value: 1)
+      end
+
+      it "raises AloomaReportingError if alooma returns an error" do
+        @client.expects(:alooma_url).returns("https://localhost").at_least(1)
+
+        http = mock
+        Net::HTTP.expects(:new).returns(http)
+        http.expects(:use_ssl=).with(true)
+        response = mock
+        response.expects(:code).returns(503)
+        http.expects(:request).returns(response)
+
+        err = Proc.new { @client.create_metric(name: 'foo', value: 1) }.must_raise(Hover::Client::AloomaReportingError)
+        err.message.must_match(/Error reporting to alooma/)
+      end
+
+      it "creates metric" do
+        parameters = {
+          "metric[name]" => 'state_waiting_labeling',
+          'metric[value]' => 133.2,
+          'metric[happened_at]' => happened_at.to_s,
+          'metric[environment]' => environment,
+          'metric[application]' => application,
+          'metric[tags][order_id]' => 2
+        }
+
+        sorted_array = parameters.to_a.sort_by(&:first)
+        metric_identifier = Digest::SHA256.hexdigest(sorted_array.to_json)
+        parameters['metric[identifier]'] = metric_identifier
+
+        @client.expects(:alooma_url).returns("https://localhost").at_least(1)
+        @client.expects(:post_to_alooma).with(parameters, 'https://localhost')
+
+        @client.create_metric(name: 'state_waiting_labeling', value: 133.2, happened_at: happened_at, tags: {order_id: 2})
+      end
+
+      it "includes remote_record_id parameter" do
+        parameters = {
+          "metric[name]" => 'name',
+          'metric[value]' => 1,
+          'metric[happened_at]' => 'foo',
+          'metric[environment]' => environment,
+          'metric[application]' => application,
+          'metric[remote_record_id]' => 7
+        }
+
+        sorted_array = parameters.to_a.sort_by(&:first)
+        metric_identifier = Digest::SHA256.hexdigest(sorted_array.to_json)
+        parameters['metric[identifier]'] = metric_identifier
+
+        @client.expects(:alooma_url).returns("https://localhost").at_least(1)
+        @client.expects(:post_to_alooma).with(parameters, 'https://localhost')
+
+        @client.create_metric(name: 'name', value: 1, remote_record_id: 7, happened_at: 'foo')
+      end
+
+      it "creates metric with nested tags" do
+        parameters = {
+          "metric[name]" => 'state_labeling',
+          'metric[value]' => 3449,
+          'metric[happened_at]' => happened_at.to_s,
+          'metric[environment]' => environment,
+          'metric[application]' => application,
+          'metric[tags][order][id]' => 2,
+          'metric[tags][order][practice]' => false,
+          'metric[tags][user][email]' => 'modeler@hover.to',
+          'metric[tags][a][b][c][]' => [11, 27],
+        }
+
+        sorted_array = parameters.to_a.sort_by(&:first)
+        metric_identifier = Digest::SHA256.hexdigest(sorted_array.to_json)
+        parameters['metric[identifier]'] = metric_identifier
+
+        @client.expects(:alooma_url).returns("https://localhost").at_least(1)
+        @client.expects(:post_to_alooma).with(parameters, 'https://localhost')
+
+        @client.create_metric(name: 'state_labeling', value: 3449, happened_at: happened_at, tags: {
+          order: {id: 2, practice: false},
+          user: {email: 'modeler@hover.to'},
+          a: {b: {c: [11, 27]}}
+        })
+      end
+
+    end
+  end
+end