syncano 3.1.4 → 4.0.0.alpha

data/lib/syncano/schema/resource_definition.rb

@@ -0,0 +1,36 @@
+module Syncano
+  class Schema
+    class ResourceDefinition
+      attr_accessor :attributes
+      attr_accessor :name
+
+      def initialize(name, raw_defitnition)
+        @raw_definition = raw_defitnition
+
+        delete_colliding_links
+
+        self.name = name
+
+        self.attributes = raw_defitnition[:attributes].map do |name, raw_attribute_definition|
+          Syncano::Schema::AttributeDefinition.new name, raw_attribute_definition
+        end
+      end
+
+      def [](key)
+        @raw_definition[key]
+      end
+
+      private
+
+      def delete_colliding_links
+        @raw_definition[:attributes].each do |k, v|
+          if @raw_definition[:associations]['links']
+            @raw_definition[:associations]['links'].delete_if do |link|
+              link['name'] == k
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/syncano/scope.rb

@@ -0,0 +1,10 @@
+module Syncano
+  class Scope
+    attr_accessor :connection, :scope_parameters
+
+    def initialize(connection, scope_parameters)
+      self.connection = connection
+      self.scope_parameters = scope_parameters
+    end
+  end
+end

data/lib/syncano/version.rb

@@ -1,4 +1,3 @@
-class Syncano
-  # Syncano version number
-  VERSION = '3.1.4'
-end
+module Syncano
+  VERSION = '4.0.0.alpha'
+end

data/spec/integration/syncano_spec.rb

@@ -0,0 +1,228 @@
+require_relative '../spec_helper'
+
+WebMock.allow_net_connect!
+
+describe Syncano do
+  before(:all) do
+    @api_key = ENV['INTEGRATION_TEST_API_KEY']
+    @api = Syncano.connect(api_key: @api_key)
+  end
+
+  before(:each) do
+    @api.instances.all.each &:destroy
+    @instance = @api.instances.create(name: "a#{SecureRandom.hex(24)}")
+    @instance.classes.all.select { |c| c.name != 'user_profile'}.each &:destroy
+    @instance.groups.all.each &:destroy
+    @instance.users.all.each &:delete
+  end
+
+  describe 'working with instances' do
+    subject { @api.instances }
+
+    it 'should raise an error on not found instance' do
+      expect { subject.find('kaszanka') }.to raise_error(Syncano::ClientError)
+    end
+
+    specify do
+      subject.create name: 'fafarafaa'
+    end
+  end
+
+  describe 'working with classes' do
+    subject { @instance.classes }
+
+    specify do
+      expect { subject.create name: 'sausage', schema: [{name: 'name', type: 'string' }] }.to create_resource
+
+      new_klass = subject.last
+
+      expect(new_klass.name).to eq('sausage')
+      expect(new_klass.schema).to eq([{'name' => 'name', 'type' => 'string'}])
+
+      new_klass.description = 'salchichón'
+      new_klass.schema = [{name: 'nombre', type: 'string'}]
+
+      saved_class =  new_klass.save
+      expect(resources_count).to eq(2)
+      expect(saved_class.schema).to eq([{'name' => 'nombre', 'type' => 'string'}])
+      expect(saved_class.description).to eq('salchichón')
+
+      from_database = subject.last
+      expect(from_database.schema).to eq([{'name' => 'nombre', 'type' => 'string'}])
+      expect(from_database.description).to eq('salchichón')
+    end
+  end
+
+  describe 'working with objects' do
+    before do
+      @class = @instance.classes.create name: 'account',
+                                        schema: [{name: 'currency', type: 'string', filter_index: true},
+                                                 {name: 'ballance', type: 'integer', filter_index: true, order_index: true}]
+    end
+
+    subject { @class.objects }
+
+
+    specify 'basic operations' do
+      expect { subject.create currency: 'USD', ballance: 1337 }.to create_resource
+
+      object = subject.first
+
+      expect(object.ballance).to eq(1337)
+      expect(object.currency).to eq('USD')
+
+      object.currency = 'GBP'
+      object.ballance = 54
+      object.save
+
+      expect(object.ballance).to eq(54)
+      expect(object.currency).to eq('GBP')
+
+      expect { object.destroy }.to destroy_resource
+    end
+
+
+    specify 'PATH and POST' do
+      initial_yuan = subject.create currency: 'CNY', ballance: 98123
+
+      yuan = subject.first
+      new_yuan = subject.first
+
+      yuan.ballance = 100000
+      yuan.save
+
+      new_yuan.currency = 'RMB'
+      new_yuan.save
+
+      yuan = subject.first
+
+      expect(yuan.currency).to eq('RMB')
+      expect(yuan.ballance).to eq(100000)
+
+      initial_yuan.save(overwrite: true)
+      yuan.reload!
+
+      expect(yuan.currency).to eq('CNY')
+      expect(yuan.ballance).to eq(98123)
+    end
+
+    specify 'filtering and ordering' do
+      usd = subject.create(currency: 'USD', ballance: 400)
+      pln = subject.create(currency: 'PLN', ballance: 1600)
+      eur = subject.create(currency: 'EUR', ballance: 400)
+      gbp = subject.create(currency: 'GPB', ballance: 270)
+      chf = subject.create(currency: 'CHF', ballance: 390)
+      uah = subject.create(currency: 'UAH', ballance: 9100)
+      rub = subject.create(currency: 'RUB')
+
+      expect(subject.all(query: { ballance: { _exists: true }}).to_a).to_not include(rub)
+      expect(subject.all(query: { currency: { _in: %w[UAH USD PLN] } }).to_a).to match_array([pln, usd, uah])
+      expect(subject.all(query: { ballance: { _lt: 400, _gte: 270 }}, order_by: '-ballance').to_a).to eq([chf, gbp])
+    end
+
+    specify 'fetching only specific fields' do
+      subject.create(currency: 'USD', ballance: 400)
+
+      account = subject.all(fields: 'currency').first
+      expect { account.currency }.to_not raise_error
+      expect { account.ballance }.to raise_error(NoMethodError)
+
+
+      account = subject.first(excluded_fields: 'currency')
+      expect { account.currency }.to raise_error(NoMethodError)
+      expect { account.ballance }.to_not raise_error
+    end
+
+    specify 'paging', slow: true do
+      104.times { subject.create }
+
+      total = 0
+      all = subject.all
+
+      loop do
+        total += all.count
+
+        if all.next?
+          all = subject.space(all.last).all
+        else
+          break
+        end
+      end
+
+      expect(total).to eq(104)
+    end
+  end
+
+  describe 'working with codeboxes traces' do
+    subject { @instance.codeboxes }
+
+
+    specify 'basic operations' do
+      expect { subject.create name: 'df', source: 'puts 1337', runtime_name: 'ruby' }.to create_resource
+
+      codebox = subject.first
+      codebox.run
+      codebox.source = 'puts 123'
+      codebox.save
+      codebox.run
+
+      without_profiling { sleep 5 }
+      traces = codebox.traces.all
+
+      expect(traces.count).to eq(2)
+
+      first = traces[1]
+
+      expect(first.status).to eq('success')
+      expect(first.result).to eq('1337')
+
+      second = traces[0]
+      expect(second.status).to eq('success')
+      expect(second.result).to eq('123')
+
+      expect { @instance.schedules.create name: 'test', interval_sec: 30, codebox: codebox.primary_key }.
+          to change { @instance.schedules.all.count }.by(1)
+
+      expect { codebox.destroy }.to destroy_resource
+    end
+  end
+
+  describe 'working with webhooks' do
+    subject { @instance.webhooks }
+
+    let!(:codebox) { @instance.codeboxes.create name: 'wurst', source: 'puts "currywurst"', runtime_name: 'ruby' }
+
+    specify do
+      expect { subject.create slug: 'web-wurst', codebox: codebox.primary_key }.to create_resource
+
+      expect(subject.first.run['result']).to eq('currywurst')
+
+      expect { subject.first.destroy }.to destroy_resource
+    end
+  end
+
+  def resources_count
+    subject.all.count
+  end
+
+  def create_resource
+    change { resources_count }.by(1)
+  end
+
+  def destroy_resource
+    change { resources_count }.to(0)
+  end
+
+  def without_profiling
+    if defined? RubyProf
+      begin
+        RubyProf.pause if RubyProf.running?
+        yield
+      ensure
+        RubyProf.resume if RubyProf.running?
+      end
+    else
+      yield
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,13 +1,19 @@
+require 'bundler'
+Bundler.setup
+
+require 'dotenv'
+Dotenv.load
+
+require 'rspec-prof' if ENV['SPEC_PROFILE']
 require 'syncano'
-require 'mocha/api'
+require 'webmock/rspec'
+
+WebMock.disable_net_connect!
 
-RSpec.configure do |config|
-  config.mock_framework = :mocha
-  config.before(:all) do
-    @syncano_api_key = ENV['SYNCANO_API_KEY'] || raise('Set SYNCANO_API_KEY environment variable!')
-    @syncano_instance_name = ENV['SYNCANO_INSTANCE_NAME'] || raise('Set SYNCANO_INSTANCE_NAME environment variable!')
+def generate_body(params)
+  JSON.generate(params)
+end
 
-    @client = ::Syncano.client(instance_name: @syncano_instance_name, api_key: @syncano_api_key)
-    @sync_client = ::Syncano.sync_client(instance_name: @syncano_instance_name, api_key: @syncano_api_key)
-  end
+def endpoint_uri(path)
+  [Syncano::Connection.api_root,"v1", path].join("/")
 end

data/spec/unit/api_spec.rb

@@ -0,0 +1,5 @@
+require 'syncano'
+
+describe Syncano::API do
+  let(:connection) { double }
+end

data/spec/unit/connection_spec.rb

@@ -0,0 +1,137 @@
+require_relative '../spec_helper'
+require 'json'
+
+describe Syncano::Connection do
+  context 'api_key' do
+    specify { expect(described_class.new(api_key: 'fafarafa')).to be_authenticated }
+    specify { expect(described_class.new).to_not be_authenticated }
+  end
+
+  describe '#request' do
+    let(:headers) { { 'X-Api-Key'=>'87a7da987da98sd7a98', 'User-Agent' => "Syncano Ruby Gem #{Syncano::VERSION}" } }
+    let(:api_key) { '87a7da987da98sd7a98' }
+
+    subject { described_class.new(api_key: api_key) }
+
+    context 'called with unsupported method' do
+      specify do
+        expect { subject.request :koza, 'fafarafa' }.
+          to raise_error(RuntimeError, 'Unsupported method "koza"')
+      end
+    end
+
+    context 'called with supported method' do
+      before do
+        stub_request(:get, endpoint_uri('somepath/')).
+          with(headers: headers).
+          to_return(body: generate_body(some: 'response'))
+      end
+
+      specify do
+        expect(subject.request(:get, 'somepath/')).to eq('some' => 'response')
+      end
+    end
+
+    context 'called with supported method returning a a client error' do
+      before do
+        stub_request(:post, endpoint_uri('instances/')).
+          with(body: { 'name' => 'koza' },
+               headers: headers).
+          to_return(body: generate_body({name: ['This field can not be "koza"']}),
+                    status: 400)
+      end
+
+      specify do
+        expect { subject.request(:post, '/v1/instances/', { name: "koza" }) }.
+            to raise_error(Syncano::ClientError)
+      end
+    end
+
+    context 'returning a server error' do
+      before do
+        stub_request(:get, endpoint_uri('error_prone/')).
+          to_return(body: 'An error occured', status: 500)
+      end
+
+      specify do
+        expect { subject.request(:get, endpoint_uri('error_prone/'), nil) }.
+          to raise_error(Syncano::ServerError)
+      end
+    end
+
+    context 'returning unsupported status code' do
+      before do
+        stub_request(:get, endpoint_uri('weird/')).to_return(body: 'O HAI!', status: 101)
+      end
+
+      specify do
+        expect { subject.request(:get, endpoint_uri('weird/')) }.to raise_error(Syncano::UnsupportedStatusError)
+      end
+    end
+
+    context 'successful returning empty body' do
+      before do
+        stub_request(:delete, endpoint_uri('instances/kiszonka/')).
+          with(headers: headers).
+          to_return(body: nil, status: 204)
+      end
+
+      specify do
+        expect { subject.request(:delete, '/v1/instances/kiszonka/', {}) }.
+          to_not raise_error
+      end
+
+    end
+  end
+
+  describe '#authenticate' do
+    subject { described_class.new }
+
+    let(:authenticate_uri) { endpoint_uri('account/auth/') }
+    let(:email) { 'kiszka@koza.com' }
+    let(:password) { 'kiszonka' }
+    let(:success_status) { 200 }
+    let(:unauthorized_status) { 401 }
+
+    context 'successful' do
+      before do
+        stub_request(:post, authenticate_uri).
+          with(body: { 'email' => email, 'password' => password } ).
+          to_return(body: successful_body, status: success_status)
+      end
+
+      it 'should get an API key' do
+        expect { subject.authenticate(email, password) }.to change { subject.authenticated? }
+      end
+
+      def successful_body
+        generate_body id: 15,
+          email: email,
+          first_name: '',
+          last_name: '',
+          account_key: 'kozakoza123'
+      end
+    end
+
+    context 'failed' do
+      before do
+        stub_request(:post, authenticate_uri).
+          with(body: { 'email' => email, 'password' => password }).
+          to_return(body: failed_body, status: unauthorized_status)
+
+      end
+
+      it 'should raise an exception' do
+        expect { subject.authenticate(email, password) }.to raise_error(Syncano::ClientError)
+      end
+
+      def failed_body
+        generate_body detail: 'Invalid email or password.'
+      end
+    end
+  end
+
+  def generate_body(params)
+    JSON.generate params
+  end
+end