syncano 4.0.0.alpha4 → 4.0.0.pre

data/spec/spec_helper.rb

@@ -7,7 +7,6 @@ Dotenv.load
 require 'rspec-prof' if ENV['SPEC_PROFILE']
 require 'syncano'
 require 'webmock/rspec'
-require 'celluloid/test'
 
 WebMock.disable_net_connect!
 
@@ -17,5 +16,4 @@ end
 
 def endpoint_uri(path)
   [Syncano::Connection.api_root,"v1", path].join("/")
-end
-
+end

data/spec/unit/connection_spec.rb

@@ -7,68 +7,108 @@ describe Syncano::Connection do
     specify { expect(described_class.new).to_not be_authenticated }
   end
 
-  describe '#authenticate' do
-    subject { described_class.new email: email, password: password }
+  describe '#request' do
+    let(:api_key) { '87a7da987da98sd7a98' }
 
-    let(:authenticate_uri) { endpoint_uri('account/auth/') }
-    let(:email) { 'kiszka@koza.com' }
-    let(:password) { 'kiszonka' }
-    let(:success_status) { 200 }
-    let(:unauthorized_status) { 401 }
+    subject { described_class.new(api_key: api_key) }
 
-    context 'successful' do
+    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
-        expect(subject).to receive(:request).
-          with(:post, described_class::AUTH_PATH, email: email, password: password).
-          and_return('account_key' => 'kEy')
+        stub_request(:get, endpoint_uri('somepath/')).
+          with(headers: {'X-Api-Key'=>'87a7da987da98sd7a98'}).
+          to_return(body: generate_body(some: 'response'))
       end
 
       specify do
-        expect { subject.authenticate }.to change { subject.authenticated? }
+        expect(subject.request(:get, 'somepath/')).to eq('some' => 'response')
       end
     end
 
-    context 'failed' do
+    context 'called with supported method returning an error' do
       before do
-        expect(subject).to receive(:request).and_raise('auth failed')
+        stub_request(:post, endpoint_uri('instances/')).
+          with(body: { 'name' => 'koza' },
+               headers: {'X-Api-Key'=>'87a7da987da98sd7a98'}).
+          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 'successful returning empty body' do
+      before do
+        stub_request(:delete, endpoint_uri('instances/kiszonka/')).
+          with(headers: {'X-Api-Key'=>'87a7da987da98sd7a98'}).
+          to_return(body: nil, status: 204)
       end
 
       specify do
-        expect { subject.authenticate }.to raise_error('auth failed')
+        expect { subject.request(:delete, '/v1/instances/kiszonka/', {}) }.
+          to_not raise_error
       end
+
     end
   end
 
-  describe '#request' do
-    let(:headers) { { 'X-Api-Key'=>'87a7da987da98sd7a98', 'User-Agent' => "Syncano Ruby Gem #{Syncano::VERSION}" } }
-    let(:api_key) { '87a7da987da98sd7a98' }
-    let(:connection_params) { { api_key: api_key, user_key: 'Us3rK3y' } }
-    let(:raw_response) { { body: 'koza' } }
-    let(:handled_response) { double :handled_response }
+  describe '#authenticate' do
+    subject { described_class.new }
 
-    subject { described_class.new(connection_params) }
+    let(:authenticate_uri) { endpoint_uri('account/auth/') }
+    let(:email) { 'kiszka@koza.com' }
+    let(:password) { 'kiszonka' }
+    let(:success_status) { 200 }
+    let(:unauthorized_status) { 401 }
 
-    context 'with supported method' do
+    context 'successful' do
       before do
-        stub_request(:get, endpoint_uri('user/method/')).
-          with(headers: headers).to_return(raw_response)
+        stub_request(:post, authenticate_uri).
+          with(body: { 'email' => email, 'password' => password } ).
+          to_return(body: successful_body, status: success_status)
+      end
 
-        expect(Syncano::Response).
-          to receive(:handle) { |raw_response| expect(raw_response.body).to eq('koza') }.
-               and_return(handled_response)
+      it 'should get an API key' do
+        expect { subject.authenticate(email, password) }.to change { subject.authenticated? }
       end
 
-      specify do
-        expect(subject.request(:get, 'user/method/')).to eq(handled_response)
+      def successful_body
+        generate_body id: 15,
+          email: email,
+          first_name: '',
+          last_name: '',
+          account_key: 'kozakoza123'
       end
     end
 
-    context 'with unsupported method' do
-      specify do
-        expect { subject.request :koza, 'fafarafa' }.
-          to raise_error(RuntimeError, 'Unsupported method "koza"')
+    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

data/spec/unit/query_builder_spec.rb

@@ -23,14 +23,14 @@ describe Syncano::QueryBuilder do
 
   describe '.first' do
     specify do
-      expect(resource_class).to receive(:first).with(connection, scope_parameters, {})
+      expect(resource_class).to receive(:first).with(connection, scope_parameters)
       subject.first
     end
   end
 
   describe '.last' do
     specify do
-      expect(resource_class).to receive(:last).with(connection, scope_parameters, {})
+      expect(resource_class).to receive(:last).with(connection, scope_parameters)
       subject.last
     end
   end

data/spec/unit/resources_base_spec.rb

@@ -5,90 +5,90 @@ require 'rspec/expectations'
 
 describe Syncano::Resources::Base do
   subject do
-    Syncano::Resources.new_resource_class(
-        Syncano::Schema::ResourceDefinition.new('same_name',
-          { :attributes => { 'name' => { 'read_only' => false,
+    Syncano::Schema.send(:new_resource_class,
+          {:attributes => {'name' => {'read_only' => false,
                                       'primary_key' => true,
                                       'required' => true,
                                       'label' => 'name',
                                       'max_length' => 64,
-                                      'type' => 'string' },
+                                      'type' => 'string'},
 
-                           'created_at' => { 'read_only' => true,
+                           'created_at' => {'read_only' => true,
                                             'required' => false,
                                             'type' => 'datetime',
-                                            'label' => 'created at' },
-                           'updated_at' => { 'read_only' => true,
+                                            'label' => 'created at'},
+                           'updated_at' => {'read_only' => true,
                                             'required' => false,
                                             'type' => 'datetime',
-                                            'label' => 'updated at' },
-                           'role' => { 'read_only' => true,
+                                            'label' => 'updated at'},
+                           'role' => {'read_only' => true,
                                       'required' => false,
-                                      'type' => 'field' },
-                           'owner' => { 'first_name' => { 'read_only' => false,
+                                      'type' => 'field'},
+                           'owner' => {'first_name' => {'read_only' => false,
                                                         'max_length' => 35,
                                                         'required' => false,
                                                         'type' => 'string',
-                                                        'label' => 'first name' },
-                                       'last_name' => { 'read_only' => false,
+                                                        'label' => 'first name'},
+                                       'last_name' => {'read_only' => false,
                                                        'max_length' => 35,
                                                        'required' => false,
                                                        'type' => 'string',
-                                                       'label' => 'last name' },
-                                       'id' => { 'read_only' => true,
+                                                       'label' => 'last name'},
+                                       'id' => {'read_only' => true,
                                                 'required' => false,
                                                 'type' => 'integer',
-                                                'label' => 'ID' },
-                                       'email' => { 'read_only' => false,
+                                                'label' => 'ID'},
+                                       'email' => {'read_only' => false,
                                                    'max_length' => 254,
                                                    'required' => true,
                                                    'type' => 'email',
-                                                   'label' => 'email address' } },
-                           'metadata' => { 'read_only' => false,
+                                                   'label' => 'email address'}},
+                           'metadata' => {'read_only' => false,
                                           'required' => false,
                                           'type' => 'field',
-                                          'label' => 'metadata' },
-                           'description' => { 'read_only' => false,
+                                          'label' => 'metadata'},
+                           'description' => {'read_only' => false,
                                              'required' => false,
                                              'type' => 'string',
-                                             'label' => 'description' } },
-           :associations => { 'read_only' => true,
+                                             'label' => 'description'}},
+           :associations => {'read_only' => true,
                              'required' => false,
                              'type' => 'links',
-                             'links' => [{ 'type' => 'detail',
-                                          'name' => 'self' },
-                                         { 'type' => 'list',
-                                          'name' => 'admins' },
-                                         { 'type' => 'list',
-                                          'name' => 'classes' },
-                                         { 'type' => 'list',
-                                          'name' => 'codeboxes' },
-                                         { 'type' => 'list',
-                                          'name' => 'runtimes' },
-                                         { 'type' => 'list',
-                                          'name' => 'invitations' },
-                                         { 'type' => 'list',
-                                          'name' => 'api_keys' },
-                                         { 'type' => 'list',
-                                          'name' => 'triggers' },
-                                         { 'type' => 'list',
-                                          'name' => 'webhooks' }] },
-           :collection => { :path => '/v1/instances/',
-                            :http_methods => ['post',
+                             'links' => [{'type' => 'detail',
+                                          'name' => 'self'},
+                                         {'type' => 'list',
+                                          'name' => 'admins'},
+                                         {'type' => 'list',
+                                          'name' => 'classes'},
+                                         {'type' => 'list',
+                                          'name' => 'codeboxes'},
+                                         {'type' => 'list',
+                                          'name' => 'runtimes'},
+                                         {'type' => 'list',
+                                          'name' => 'invitations'},
+                                         {'type' => 'list',
+                                          'name' => 'api_keys'},
+                                         {'type' => 'list',
+                                          'name' => 'triggers'},
+                                         {'type' => 'list',
+                                          'name' => 'webhooks'}]},
+           :collection => {:path => '/v1/instances/',
+                           :http_methods => ['post',
                                              'get'],
-                           :params => [] },
-           :member => { :path => '/v1/instances/{ name }/',
+                           :params => []},
+           :member => {:path => '/v1/instances/{name}/',
                        :http_methods => ['put',
                                          'get',
                                          'patch',
                                          'delete'],
-                       :params => ['name'] },
-           :custom_methods => [] })
+                       :params => ['name']},
+           :custom_methods => []},
+          'some_name'
     )
   end
 
-  let(:connection) { double('connection') }
-  let(:scope_parameters) { double('scope_parameters') }
+  let(:connection) { double('connection')}
+  let(:scope_parameters) { double('scope_parameters')}
 
   describe '.find' do
     let(:response) {
@@ -140,7 +140,7 @@ describe Syncano::Resources::Base do
     end
 
     it 'should init attributes' do
-      resource = subject.new(connection, {}, { name: 'test' })
+      resource = subject.new(connection, {}, { name: 'test' }, true)
       expect(resource.name).to eq('test')
     end
 
@@ -153,94 +153,33 @@ describe Syncano::Resources::Base do
       resource = subject.new(connection, {}, { links: { self: '/v1/instances/test/' }, name: 'test' }, false)
       expect(resource.changed?).to eq(true)
     end
-  end
-
-  describe '#new_record?' do
-    let(:resource) { subject.new connection, {}, { name: 'asd' }, from_db }
-
-    context 'is true' do
-      let(:from_db) { false }
 
-      specify { expect(resource.new_record?).to eq(true) }
+    it 'should mark resource as not new if initialized with self path' do
+      resource = subject.new(connection, {}, { links: { self: '/v1/instances/test/' } }, true)
+      expect(resource.new_record?).to be(false)
     end
 
-    context 'is false' do
-      let(:from_db) { true }
-
-      specify { expect(resource.new_record?).to eq(false) }
+    it 'should mark resource as new if initialized without self path' do
+      resource = subject.new(connection, {}, { name: 'test' }, true)
+      expect(resource.new_record?).to be(true)
     end
   end
 
-  describe "persisting data" do
-    shared_context "resource invalid" do
-      before { expect(resource).to receive(:valid?) { false } }
-    end
-
-    shared_context "resource valid" do
-      before do
-        # expect(instance_of(Syncano::Resource::Base)).to receive(:valid?) { true }
-
-        expect(resource).to receive(:valid?) { true }
-
-        expect(connection).to receive(:request).
-                                with(instance_of(Symbol), instance_of(String), instance_of(Hash)).
-                                and_return({})
-      end
-    end
-
-    let(:resource) { subject.new connection, {}, {}, false }
+  describe '.create' do
+    it 'should create new object in Syncano' do
 
-    describe ".create!" do
-      before do
-        expect(subject).to receive(:new).and_return(resource)
-        expect(resource).to receive(:save!).and_return(resource)
-      end
-
-      specify { expect(subject.create!(connection, {}, {})).to eq(resource) }
     end
+  end
 
-    describe ".create" do
-      before do
-        expect(subject).to receive(:new).and_return(resource)
-        expect(resource).to receive(:save).and_return(false)
-      end
-
-      specify { expect(subject.create(connection, {}, {})).to eq(resource) }
-      specify { expect(subject.create(connection, {}, {}).new_record?).to eq(true) }
-    end
-
-    describe "#save" do
-      context "when invalid" do
-        include_context "resource invalid"
-
-        specify { expect(resource.save).to eq(false) }
-      end
-
-      context "when valid" do
-        include_context "resource valid"
+  describe '.update_attributes' do
+    it 'should create update object\'s attributes in Syncano' do
 
-        specify { expect(resource.save).to be_kind_of(Syncano::Resources::Base) }
-      end
     end
+  end
 
-    describe "#save!" do
-      context "when invalid" do
-        include_context "resource invalid"
-
-        specify do
-          expect {
-            resource.save!
-          }.to raise_error(Syncano::Resources::ResourceInvalid)
-        end
-      end
-
-      context "when valid" do
-        include_context "resource valid"
+  describe '.destroy' do
+    it 'should delete object from Syncano' do
 
-        specify do
-          expect(resource.save!).to be_kind_of(Syncano::Resources::Base)
-        end
-      end
     end
   end
 end

data/spec/unit/schema/resource_definition_spec.rb

@@ -1,35 +1,14 @@
 require_relative  '../../spec_helper'
 
 describe Syncano::Schema::ResourceDefinition do
-  let(:attribute) { double 'attribute' }
-  let(:definition) do
-    described_class.new(name, attributes: { 'koza' => raw_attribute },
-                        associations: {
-                          'links' => [{ 'name' => 'koza', 'type' => 'detail' }]
-                        })
-  end
-  let(:name) { 'Kiszka' }
   let(:raw_attribute) { double 'raw attribute' }
+  let(:attribute) { double 'attribute' }
 
   before do
     expect(Syncano::Schema::AttributeDefinition).to receive(:new).with('koza', raw_attribute).and_return(attribute)
   end
 
-  specify { expect(definition.attributes).to eq([attribute]) }
-
-  specify { expect(definition.name).to eq(name) }
-
-  it 'should delete colliding links' do
-    expect(definition[:associations]['links']).to be_empty
-  end
-
-  describe 'top_level?' do
-    context "when is top level" do
-      pending "to be done"
-    end
-
-    context "when is not top level" do
-      pending "to be done"
-    end
+  it 'should create AttributeDefinition objects' do
+    expect(described_class.new(attributes: { 'koza' => raw_attribute }).attributes).to eq([attribute])
   end
 end