k_sequencing 0.1.24 → 0.1.25

data/test/fixtures/prediction/create.json

@@ -0,0 +1,19 @@
+{
+  "data": {
+    "image": {
+      "id": "5a44671ab3957c2ab5c33326",
+      "answer": "approved",
+      "credit_charged": 0,
+      "custom_id": null,
+      "data": "https://s3-ap-northeast-1.amazonaws.com/marinchat/uploads/user/6951939/profile_icon/veOSbIBCR.jpg",
+      "postback_url": "http://localhost:3000/projects",
+      "processed_at": "2017-11-16T10:10:56.282+07:00",
+      "project_id": 93,
+      "status": "processed"
+    }
+  },
+  "meta": {
+    "code": 200,
+    "message": "success"
+  }
+}

data/test/helper/file_reader.rb

@@ -0,0 +1,11 @@
+class FileReader
+  attr_reader :file
+
+  def initialize(file)
+    @file = file
+  end
+
+  def read_json
+    JSON.parse(File.read(file))
+  end
+end

data/test/k_sequencing/client_response_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module KSequencing
+  class ResponseTest < Minitest::Test
+    def test_new_success_response
+      response = Response.new('response', 200, 'success', 'meta', 5)
+      refute_nil(response)
+      refute_nil(response.data)
+      assert_equal(true, response.successful?)
+      assert_equal('response', response.data)
+      assert_equal('success', response.message)
+      assert_equal('meta', response.meta)
+      assert_equal(5, response.total)
+    end
+
+    def test_failure_response
+      response = Response.new('response', 500, 'failure', 'meta')
+      refute_nil(response)
+      refute_nil(response.data)
+      assert_equal(false, response.successful?)
+      assert_equal('response', response.data)
+      assert_equal('failure', response.message)
+      assert_equal('meta', response.meta)
+      assert_equal(0, response.total)
+    end
+  end
+end

data/test/k_sequencing/client_test.rb

@@ -0,0 +1,189 @@
+require 'test_helper'
+
+module KSequencing
+  class ClientTest < TestBase
+    def test_create_image_choices
+      stub_request(:post, IMAGE_CHOICES_URL)
+        .with(headers: { Authorization: options[:token] })
+        .to_return(body: JSON.generate(image_choice), status: 200)
+      response = client.create_image_choices(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_create_image_closed_question
+      stub_request(:post, IMAGE_CLOSED_QUESTIONS_URL)
+        .with(headers: { Authorization: options[:token] })
+        .to_return(body: JSON.generate(image_closed_question), status: 200)
+      response = client.create_image_closed_questions(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_create_image_messages
+      stub_request(:post, IMAGE_MESSAGES_URL)
+        .with(headers: { Authorization: options[:token] })
+        .to_return(body: JSON.generate(image_message), status: 200)
+      response = client.create_image_messages(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_create_image_photo_tag
+      stub_request(:post, IMAGE_PHOTO_TAGS)
+        .with(headers: { Authorization: options[:token] })
+        .to_return(body: JSON.generate(image_photo_tags), status: 200)
+      response = client.create_image_photo_tags(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_create_prediction
+      stub_request(:post, PREDICTIONS_URL)
+        .with(headers: { Authorization: options[:token] })
+        .to_return(body: JSON.generate(prediction), status: 200)
+      response = client.create_prediction(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_list_image_choice
+      stub_request(:get, IMAGE_CHOICES_URL)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_choices), status: 200)
+      response = client.get_image_choice(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_list_image_closed_question
+      stub_request(:get, IMAGE_CLOSED_QUESTIONS_URL)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_closed_questions), status: 200)
+      response = client.get_image_closed_question(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_list_image_message
+      stub_request(:get, IMAGE_MESSAGES_URL)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_messages), status: 200)
+      response = client.get_image_message(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_list_image_photo_tag
+      stub_request(:get, IMAGE_PHOTO_TAGS)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_photo_tags), status: 200)
+      response = client.get_image_photo_tag(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_list_prediction
+      stub_request(:get, PREDICTIONS_URL)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(prediction), status: 200)
+      response = client.get_prediction(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_find_image_choice
+      stub_request(:get, IMAGE_CHOICE_URL)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_choice), status: 200)
+      response = client.find_by_id_image_choice(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_find_image_closed_question
+      stub_request(:get, IMAGE_CLOSED_QUESTION_URL)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_closed_question), status: 200)
+      response = client.find_by_id_image_closed_question(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_find_image_message
+      stub_request(:get, IMAGE_MESSAGE_URL)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_message), status: 200)
+      response = client.find_by_id_image_message(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_find_photo_tag
+      stub_request(:get, IMAGE_PHOTO_TAG)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_photo_tag), status: 200)
+      response = client.find_by_id_image_photo_tag(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_find_prediction
+      mock_id = '1'
+      stub_request(:get, PREDICTIONS_URL + '/' + mock_id)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(prediction), status: 200)
+      response = client.find_by_id_prediction(mock_id, options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_find_image
+      mock_id = '1'
+      stub_request(:get, IMAGE_URL + '/' + mock_id)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(prediction), status: 200)
+      response = client.find_image(mock_id, options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    private
+
+    def client
+      @client ||= KSequencing.client
+    end
+  end
+end

data/test/k_sequencing/connection_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+module KSequencing
+  class ConnectionTest < Minitest::Test
+    def test_get_success
+      stub_request(:get, 'http://localhost:3000')
+        .to_return(body: JSON.generate(data: 'foo', meta: { message: 'success', code: 200 }), status: 200)
+      response = connection.get('http://localhost:3000', {})
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      assert_equal('success', response.message)
+      assert_equal('success', response.meta['message'])
+      assert_equal(200, response.status)
+    end
+
+    def test_get_failed
+      stub_request(:get, 'http://localhost:3000')
+        .to_return(body: JSON.generate(data: '', meta: { message: 'Internal Server Error', code: 500 }), status: 500)
+      response = connection.get('http://localhost:3000', {})
+      assert_instance_of(Response, response)
+      assert_equal('500', response.status)
+    end
+
+    def test_post_success
+      stub_request(:post, 'http://localhost:3000')
+        .to_return(body: JSON.generate(data: 'foo', meta: { code: 200 }), status: 200)
+      response = connection.post('http://localhost:3000', {})
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+    end
+
+    def test_post_failed
+      stub_request(:post, 'http://localhost:3000')
+        .to_return(body: JSON.generate(data: '', meta: { code: 500, message: 'Internal Server Error' }), status: 500)
+      response = connection.post('http://localhost:3000', {})
+      assert_instance_of(Response, response)
+      assert_equal('500', response.status)
+    end
+
+    def test_connection_failed
+      stub_request(:get, 'http://localhost:3000')
+        .to_raise(Faraday::ConnectionFailed.new('connection failed'))
+      response = connection.get('http://localhost:3000')
+      assert_instance_of(Response, response)
+    end
+
+    def test_bad_request_status
+      stub_request(:get, 'http://localhost:3000')
+        .to_return(status: 400, body: JSON.generate(data: '', meta: { message: 'bad request', code: 400 }))
+      response = connection.get('http://localhost:3000', {})
+      assert_instance_of(Response, response)
+      assert_equal('400', response.status)
+    end
+
+    def test_forbidden_status
+      stub_request(:get, 'http://localhost:3000')
+        .to_return(body: JSON.generate(data: '', meta: { message: 'forbidden', code: 403 }), status: 403)
+      response = connection.get('http://localhost:3000', {})
+      assert_instance_of(Response, response)
+      assert_equal('403', response.status)
+    end
+
+    def test_not_found_status
+      stub_request(:get, 'http://localhost:3000')
+        .to_return(body: JSON.generate(data: '', meta: { message: 'not found', code: 404 }), status: 404)
+      response = connection.get('http://localhost:3000', {})
+      assert_instance_of(Response, response)
+      assert_equal('404', response.status)
+    end
+
+    def test_edge_case_error
+      stub_request(:get, 'http://localhost:3000')
+        .to_return(body: JSON.generate(data: '', meta: { message: 'version not supported', code: 505 }), status: 505)
+      response = connection.get('http://localhost:3000', {})
+      assert_instance_of(Response, response)
+      assert_equal('505', response.status)
+    end
+
+    private
+
+    def connection
+      @connection ||= KSequencing::Connection.new
+    end
+  end
+end

data/test/k_sequencing/image_choices_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module KSequencing
+  class ImageChoiceTest < TestBase
+    def test_all
+      stub_request(:get, IMAGE_CHOICES_URL)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_choices), status: 200)
+      response = ImageChoice.new.all(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_create
+      stub_request(:post, IMAGE_CHOICES_URL)
+        .with(headers: { Authorization: options[:token] })
+        .to_return(body: JSON.generate(image_choice), status: 200)
+      response = ImageChoice.new.create(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_find
+      stub_request(:get, IMAGE_CHOICE_URL)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_choice), status: 200)
+      response = ImageChoice.new.find_by(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+  end
+end

data/test/k_sequencing/image_closed_questions_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module KSequencing
+  class ImageClosedQuestionTest < TestBase
+    def test_all
+      stub_request(:get, IMAGE_CLOSED_QUESTIONS_URL)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_closed_questions), status: 200)
+      response = ImageClosedQuestion.new.all(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_create
+      stub_request(:post, IMAGE_CLOSED_QUESTIONS_URL)
+        .with(headers: { Authorization: options[:token] })
+        .to_return(body: JSON.generate(image_closed_question), status: 200)
+      response = ImageClosedQuestion.new.create(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_find
+      stub_request(:get, IMAGE_CLOSED_QUESTION_URL)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_closed_question), status: 200)
+      response = ImageClosedQuestion.new.find_by(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+  end
+end

data/test/k_sequencing/image_messages_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module KSequencing
+  class ImageMessageTest < TestBase
+    def test_all
+      stub_request(:get, IMAGE_MESSAGES_URL)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_messages), status: 200)
+      response = ImageMessage.new.all(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_create
+      stub_request(:post, IMAGE_MESSAGES_URL)
+        .with(headers: { Authorization: options[:token] })
+        .to_return(body: JSON.generate(image_message), status: 200)
+      response = ImageMessage.new.create(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_find
+      stub_request(:get, IMAGE_MESSAGE_URL)
+        .with(query: { token: options[:token] })
+        .to_return(body: JSON.generate(image_message), status: 200)
+      response = ImageMessage.new.find_by(options)
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+  end
+end