datawow 1.2.0

data/test/datawow/connection_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+module Datawow
+  class ConnectionTest < Minitest::Test
+    def test_get_success
+      stub_request(:get, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: 'foo', meta: { message: 'success', code: 200 }), status: 200)
+      response = connection.get('/images', {})
+      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, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: '', meta: { message: 'Internal Server Error', code: 500 }), status: 500)
+      response = connection.get('/images', {})
+      assert_instance_of(Response, response)
+      assert_equal(500, response.status)
+    end
+
+    def test_post_success
+      stub_request(:post, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: 'foo', meta: { code: 200 }), status: 200)
+      response = connection.post('/images', {})
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+    end
+
+    def test_post_failed
+      stub_request(:post, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: '', meta: { code: 500, message: 'Internal Server Error' }), status: 500)
+      response = connection.post('/images', {})
+      assert_instance_of(Response, response)
+      assert_equal(500, response.status)
+    end
+
+    def test_connection_failed
+      stub_request(:get, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_raise(Faraday::ConnectionFailed.new('connection failed'))
+      response = connection.get('/images')
+      assert_instance_of(Response, response)
+    end
+
+    def test_bad_request_status
+      stub_request(:get, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(status: 400, body: JSON.generate(data: '', meta: { message: 'bad request', code: 400 }))
+      response = connection.get('/images', {})
+      assert_instance_of(Response, response)
+      assert_equal(400, response.status)
+    end
+
+    def test_forbidden_status
+      stub_request(:get, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: '', meta: { message: 'forbidden', code: 403 }), status: 403)
+      response = connection.get('/images', {})
+      assert_instance_of(Response, response)
+      assert_equal(403, response.status)
+    end
+
+    def test_not_found_status
+      stub_request(:get, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: '', meta: { message: 'not found', code: 404 }), status: 404)
+      response = connection.get('/images', {})
+      assert_instance_of(Response, response)
+      assert_equal(404, response.status)
+    end
+
+    def test_edge_case_error
+      stub_request(:get, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: '', meta: { message: 'version not supported', code: 505 }), status: 505)
+      response = connection.get('/images', {})
+      assert_instance_of(Response, response)
+      assert_equal(505, response.status)
+    end
+
+    private
+
+    def connection
+      @connection ||= Datawow::Connection.new(model: :image)
+    end
+  end
+end

data/test/datawow/connector_test.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Datawow
+  class ConnectorTest < Minitest::Test
+    def test_get_success
+      stub_request(:get, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: 'foo', meta: { message: 'success', code: 200 }), status: 200)
+      response = connector.get
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      assert_equal('success', response.message)
+      assert_equal('success', response.meta['message'])
+    end
+
+    def test_get_failed
+      stub_request(:get, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: '', meta: { message: 'Internal Server Error', code: 500 }), status: 500)
+      response = connector.get
+      assert_instance_of(Response, response)
+      assert_equal(500, response.status)
+    end
+
+    def test_post_success
+      stub_request(:post, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: 'foo', meta: { code: 200 }), status: 200)
+      response = connector.post
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+    end
+
+    def test_post_failed
+      stub_request(:post, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: '', meta: { code: 500, message: 'Internal Server Error' }), status: 500)
+      response = connector.post
+      assert_instance_of(Response, response)
+      assert_equal(500, response.status)
+    end
+
+    def test_bad_request_status
+      stub_request(:get, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(status: 400, body: JSON.generate(data: '', meta: { message: 'bad request', code: 400 }))
+      response = connector.get
+      assert_instance_of(Response, response)
+      assert_equal(400, response.status)
+    end
+
+    def test_forbidden_status
+      stub_request(:get, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: '', meta: { message: 'forbidden', code: 403 }), status: 403)
+      response = connector.get
+      assert_instance_of(Response, response)
+      assert_equal(403, response.status)
+    end
+
+    def test_not_found_status
+      stub_request(:get, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: '', meta: { message: 'not found', code: 404 }), status: 404)
+      response = connector.get
+      assert_instance_of(Response, response)
+      assert_equal(404, response.status)
+    end
+
+    def test_edge_case_error
+      stub_request(:get, 'https://kiyo-image.datawow.io/api/v1/images')
+        .to_return(body: JSON.generate(data: '', meta: { message: 'version not supported', code: 505 }), status: 505)
+      response = connector.get
+      assert_instance_of(Response, response)
+      assert_equal(505, response.status)
+    end
+
+    private
+
+    def connector
+      connector ||= Connector.new('images', :image, token: 'test')
+    end
+  end
+end

data/test/datawow/image_choices_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Datawow
+  class ImageChoiceTest < TestBase
+    def test_all
+      stub_request(:get, IMAGE_CHOICES_URL)
+        .to_return(body: JSON.generate(image_choices), status: 200)
+      response = model.all
+
+      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)
+        .to_return(body: JSON.generate(image_choice), status: 200)
+      response = model.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_CHOICES_URL}?id=test")
+        .to_return(body: JSON.generate(image_choice), status: 200)
+      response = model.find_by(id: 'test')
+
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    private
+
+    def model
+      @model ||= ImageChoice.new
+      @model.token = 'test'
+      @model
+    end
+  end
+end

data/test/datawow/image_closed_questions_test.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+module Datawow
+  class ImageClosedQuestionTest < TestBase
+    def test_all
+      stub_request(:get, IMAGE_CLOSED_QUESTIONS_URL)
+        .to_return(body: JSON.generate(image_closed_questions), status: 200)
+      response = model.all
+
+      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)
+        .to_return(body: JSON.generate(image_closed_question), status: 200)
+      response = model.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_QUESTIONS_URL}?id=test")
+        .to_return(body: JSON.generate(image_closed_question), status: 200)
+      response = model.find_by(id: 'test')
+
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    private
+
+    def model
+      @model ||= ImageClosedQuestion.new
+      @model.token = 'test'
+      @model
+    end
+  end
+end

data/test/datawow/image_messages_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Datawow
+  class ImageMessageTest < TestBase
+    def test_all
+      stub_request(:get, IMAGE_MESSAGES_URL)
+        .to_return(body: JSON.generate(image_messages), status: 200)
+      response = model.all
+
+      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)
+        .to_return(body: JSON.generate(image_message), status: 200)
+      response = model.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_MESSAGES_URL}?id=test")
+        .to_return(body: JSON.generate(image_message), status: 200)
+      response = model.find_by(id: 'test')
+
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    private
+
+    def model
+      @model ||= ImageMessage.new
+      @model.token = 'test'
+      @model
+    end
+  end
+end

data/test/datawow/image_photo_tags_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Datawow
+  class ImagePhotoTagsTest < TestBase
+    def test_all
+      stub_request(:get, IMAGE_PHOTO_TAGS)
+        .to_return(body: JSON.generate(image_photo_tags), status: 200)
+      response = model.all
+
+      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_PHOTO_TAGS)
+        .to_return(body: JSON.generate(image_photo_tags), status: 200)
+      response = model.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_PHOTO_TAGS}?id=test")
+        .to_return(body: JSON.generate(image_photo_tag), status: 200)
+      response = model.find_by(id: 'test')
+
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    private
+
+    def model
+      @model ||= ImagePhotoTag.new
+      @model.token = 'test'
+      @model
+    end
+  end
+end

data/test/datawow/nanameue_human_test.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+module Datawow
+  class NanameueHumanTest < TestBase
+    def test_all
+      stub_request(:get, NANAMEUE_HUMAN_URL)
+        .to_return(body: JSON.generate(nanameue_humans), status: 200)
+      response = model.all
+
+      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, NANAMEUE_HUMAN_URL)
+        .to_return(body: JSON.generate(nanameue_human), status: 201)
+      response = model.create(options)
+
+      assert_instance_of(Response, response)
+      assert_equal(201, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    def test_find
+      stub_request(:get, "#{NANAMEUE_HUMAN_URL}?id=test")
+        .to_return(body: JSON.generate(nanameue_human), status: 200)
+      response = model.find_by(id: 'test')
+
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    private
+
+    def model
+      @model ||= NanameueHuman.new
+      @model.token = 'test'
+      @model
+    end
+  end
+end

data/test/datawow/predictors_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Datawow
+  class PredictorsTest < TestBase
+    def test_all
+      stub_request(:get, PREDICTIONS_URL)
+        .to_return(body: JSON.generate(predictions), status: 200)
+      response = model.all
+
+      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, PREDICTIONS_URL)
+        .to_return(body: JSON.generate(prediction), status: 200)
+      response = model.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, "#{PREDICTIONS_URL}/1")
+        .to_return(body: JSON.generate(prediction), status: 200)
+      response = model.find_by(id: '1')
+
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    private
+
+    def model
+      @model ||= Predictor.new
+      @model.token = 'test'
+      @model
+    end
+  end
+end

data/test/datawow/text_categories_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Datawow
+  class TextCategoriesTest < TestBase
+    def test_all
+      stub_request(:get, TEXT_CATEGORY_URL)
+        .to_return(body: JSON.generate(text_categories), status: 200)
+      response = model.all
+
+      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, TEXT_CATEGORY_URL)
+        .to_return(body: JSON.generate(text_categories), status: 200)
+      response = model.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, "#{TEXT_CATEGORY_URL}?id=1")
+        .to_return(body: JSON.generate(text_category), status: 200)
+      response = model.find_by(id: '1')
+
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    private
+
+    def model
+      @model ||= TextCategory.new
+      @model.token = 'test'
+      @model
+    end
+  end
+end

data/test/datawow/text_closed_questions_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Datawow
+  class TextClosedQuestionsTest < TestBase
+    def test_all
+      stub_request(:get, TEXT_CLOSED_QUESTION_URL)
+        .to_return(body: JSON.generate(text_conversations), status: 200)
+      response = model.all
+
+      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, TEXT_CLOSED_QUESTION_URL)
+        .to_return(body: JSON.generate(text_conversations), status: 200)
+      response = model.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, "#{TEXT_CLOSED_QUESTION_URL}?id=1")
+        .to_return(body: JSON.generate(text_conversation), status: 200)
+      response = model.find_by(id: '1')
+
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    private
+
+    def model
+      @model ||= TextClosedQuestion.new
+      @model.token = 'test'
+      @model
+    end
+  end
+end

data/test/datawow/text_conversations_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Datawow
+  class TextConversationsTest < TestBase
+    def test_all
+      stub_request(:get, TEXT_CONVERSATION_URL)
+        .to_return(body: JSON.generate(text_closed_questions), status: 200)
+      response = model.all
+
+      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, TEXT_CONVERSATION_URL)
+        .to_return(body: JSON.generate(text_closed_questions), status: 200)
+      response = model.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, "#{TEXT_CONVERSATION_URL}?id=1")
+        .to_return(body: JSON.generate(text_closed_question), status: 200)
+      response = model.find_by(id:1)
+
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    private
+
+    def model
+      @model ||= TextConversation.new
+      @model.token = 'test'
+      @model
+    end
+  end
+end

data/test/datawow/video_classifications_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Datawow
+  class VideoClassificationsTest < TestBase
+    def test_all
+      stub_request(:get, VIDEO_URL)
+        .to_return(body: JSON.generate(videos), status: 200)
+      response = model.all
+
+      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, VIDEO_URL)
+        .to_return(body: JSON.generate(videos), status: 200)
+      response = model.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, "#{VIDEO_URL}/1")
+        .to_return(body: JSON.generate(video), status: 200)
+      response = model.find_by(id: 1)
+
+      assert_instance_of(Response, response)
+      assert_equal(200, response.status)
+      refute_nil(response.data)
+      refute_nil(response.meta)
+    end
+
+    private
+
+    def model
+      @model ||= VideoClassification.new
+      @model.token = 'test'
+      @model
+    end
+  end
+end

data/test/datawow_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+module Datawow
+  class DatawowTest < Minitest::Test
+    def test_setup
+      Datawow.setup { |config| }
+    end
+
+    def test_image_closed_question
+      closed_question = Datawow.image_closed_question
+      refute_nil(closed_question)
+    end
+
+    def test_image_photo_tag
+      photo_tag = Datawow.image_photo_tag
+      refute_nil(photo_tag)
+    end
+
+    def test_image_choice
+      choice = Datawow.image_choice
+      refute_nil(choice)
+    end
+
+    def test_image_message
+      message = Datawow.image_message
+      refute_nil(message)
+    end
+
+    def test_prediction
+      prediction = Datawow.prediction
+      refute_nil(prediction)
+    end
+  end
+end