mode-sdk 0.0.1

data/spec/lib/mode/sdk/column_spec.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mode::Sdk::Column do
+  describe '#validate!' do
+    it 'returns true if no exceptions are raised' do
+      column = Mode::Sdk::Column.new({})
+
+      expect(column).to receive(:validate_keys!)
+      expect(column).to receive(:validate_name!)
+      expect(column).to receive(:validate_type!)
+
+      expect(column.validate!).to eq(true)
+    end
+  end
+
+  describe '#validate_keys!' do
+    it 'raises error if column is missing name key' do
+      column = Mode::Sdk::Column.new(type: 'text')
+
+      expect {
+        column.send(:validate_keys!)
+      }.to raise_error(Mode::Sdk::Column::InvalidError) do |exception|
+        expect(exception.message).to match(/missing required key 'name'/i)
+      end
+    end
+
+    it 'raises error if column is missing type key' do
+      column = Mode::Sdk::Column.new(name: 'name')
+
+      expect {
+        column.send(:validate_keys!)
+      }.to raise_error(Mode::Sdk::Column::InvalidError) do |exception|
+        expect(exception.message).to match(/missing required key 'type'/i)
+      end
+    end
+
+    it 'raises error if column has extra keys' do
+      column = Mode::Sdk::Column.new(name: 'name', type: 'text', foo: 'bar')
+
+      expect {
+        column.send(:validate_keys!)
+      }.to raise_error(Mode::Sdk::Column::InvalidError) do |exception|
+        expect(exception.message).to match(/has unexpected keys/i)
+      end
+    end
+
+    it 'returns true for valid keys' do
+      column = Mode::Sdk::Column.new(name: nil, type: nil)
+
+      expect(column.send(:validate_keys!)).to eq(true)
+    end
+  end
+
+  describe '#validate_name!' do
+    it 'raises error if column name is too short' do
+      column = Mode::Sdk::Column.new(name: 'n')
+
+      expect {
+        column.send(:validate_name!)
+      }.to raise_error(Mode::Sdk::Column::InvalidError) do |exception|
+        expect(exception.message).to match(/name is invalid/i)
+      end
+    end
+
+    it 'raises error if column name is too long' do
+      column = Mode::Sdk::Column.new(name: 'no' * 50)
+
+      expect {
+        column.send(:validate_name!)
+      }.to raise_error(Mode::Sdk::Column::InvalidError) do |exception|
+        expect(exception.message).to match(/name is invalid/i)
+      end
+    end
+
+    it 'returns true for valid name' do
+      column = Mode::Sdk::Column.new(name: 'name')
+
+      expect(column.send(:validate_name!)).to eq(true)
+    end
+  end
+
+  describe '#validate_type!' do
+    it 'raises error if column type is not recognized' do
+      column = Mode::Sdk::Column.new(type: 'nope')
+
+      expect {
+        column.send(:validate_type!)
+      }.to raise_error(Mode::Sdk::Column::InvalidError) do |exception|
+        expect(exception.message).to match(/type is invalid/i)
+      end
+    end
+
+    it 'returns true for valid type' do
+      column = Mode::Sdk::Column.new(type: 'integer')
+
+      expect(column.send(:validate_type!)).to eq(true)
+    end
+  end
+end

data/spec/lib/mode/sdk/hash_util_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mode::Sdk::HashUtil do
+  let :util do
+    Object.new.extend(Mode::Sdk::HashUtil)
+  end
+
+  describe '#stringify_keys' do
+    it 'stringifies keys' do
+      hash = { foo1: 'bar1', foo2: 'bar2' }
+
+      expect(util.stringify_keys(hash)).to eq(
+        'foo1' => 'bar1', 'foo2' => 'bar2')
+    end
+  end
+end

data/spec/lib/mode/sdk/table_import_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mode::Sdk::TableImport do
+  describe '#poll' do
+    it 'polls state until completed' do
+      import = Mode::Sdk::TableImport.new('/some/path')
+
+      reprs = %w(new enqueued running running failed).map do |state|
+        { 'state' => state }
+      end
+
+      expect(import).to receive(:fetch_repr).and_return(*reprs)
+
+      expect { |b|
+        import.poll(0, &b)
+      }.to yield_successive_args(*reprs)
+    end
+  end
+
+  describe '#fetch_repr' do
+    it 'performs get request' do
+      import = Mode::Sdk::TableImport.new('/some/path')
+
+      response = double(:response, body: { 'state' => 'enqueued' })
+
+      expect(Mode::Sdk::Client).to receive(:get).and_return(response)
+
+      expect(import.send(:fetch_repr)).to eq('state' => 'enqueued')
+    end
+  end
+end

data/spec/lib/mode/sdk/table_spec.rb

@@ -0,0 +1,191 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mode::Sdk::Table do
+  describe '#owner' do
+    it 'defaults to authenticated username' do
+      expect(Mode::Sdk).to receive(:username).and_return('sally')
+      table = Mode::Sdk::Table.new('name')
+      expect(table.send(:owner)).to eq('sally')
+    end
+
+    it 'uses owner option if present' do
+      expect(Mode::Sdk).to receive(:username).never
+      table = Mode::Sdk::Table.new('name', owner: 'earl')
+      expect(table.send(:owner)).to eq('earl')
+    end
+  end
+
+  describe '#resource_path' do
+    it 'forms path correctly' do
+      table = Mode::Sdk::Table.new('name', owner: 'sally')
+      expect(table.send(:resource_path)).to eq('/api/sally/tables/name')
+    end
+  end
+
+  describe '#exists?' do
+    it 'is true if table exists' do
+      response = Mode::Sdk::Client::Response.new(nil)
+      expect(response).to receive(:code).and_return(200)
+      expect(Mode::Sdk::Client).to receive(:head).and_return(response)
+
+      table = Mode::Sdk::Table.new('name', owner: 'sally')
+      expect(table.send(:exists?)).to eq(true)
+    end
+
+    it 'is false if table does not exist' do
+      response = Mode::Sdk::Client::Response.new(nil)
+      expect(response).to receive(:code).and_return(404)
+      expect(Mode::Sdk::Client).to receive(:head).and_return(response)
+
+      table = Mode::Sdk::Table.new('name', owner: 'sally')
+      expect(table.send(:exists?)).to eq(false)
+    end
+  end
+
+  describe '#create' do
+    it 'creates table' do
+      table = Mode::Sdk::Table.new('name')
+
+      expect(table).to receive(:upsert) do |*args|
+        expect(args.first).to eq(:create)
+      end
+
+      expect(table.create).to eq(true)
+    end
+  end
+
+  describe '#replace' do
+    it 'creates table' do
+      table = Mode::Sdk::Table.new('name')
+
+      expect(table).to receive(:upsert) do |*args|
+        expect(args.first).to eq(:replace)
+      end
+
+      expect(table.replace).to eq(true)
+    end
+  end
+
+  describe '#validate!' do
+    it 'raises exception if upload token is missing' do
+      table = Mode::Sdk::Table.new('no')
+
+      expect {
+        table.send(:validate!)
+      }.to raise_error(Mode::Sdk::Table::InvalidError) do |exception|
+        expect(exception.message).to match(/missing required attribute/i)
+      end
+    end
+
+    it 'raises exception if table name is invalid' do
+      table = Mode::Sdk::Table.new('no')
+      table.upload_token = 'token'
+
+      expect {
+        table.send(:validate!)
+      }.to raise_error(Mode::Sdk::Table::InvalidError) do |exception|
+        expect(exception.message).to match(/invalid name/i)
+      end
+    end
+
+    it 'returns true if no exceptions are raised' do
+      table = Mode::Sdk::Table.new('name')
+      table.upload_token = 'token'
+
+      expect_any_instance_of(Mode::Sdk::ColumnSet).to(
+        receive(:validate!).at_least(:once).and_return(true))
+
+      expect(table.send(:validate!)).to eq(true)
+    end
+  end
+
+  describe '#upsert' do
+    let :response do
+      Mode::Sdk::Client::Response.new(nil)
+    end
+
+    describe 'for create' do
+      it 'creates table' do
+        table = Mode::Sdk::Table.new('name', owner: 'owner')
+
+        expect(table).to receive(:validate!)
+        expect(response).to receive(:code).and_return(200)
+        expect(Mode::Sdk::Client).to receive(:post).and_return(response)
+
+        expect(table.send(:upsert, :create)).to be_an_instance_of(
+          Mode::Sdk::Client::Response)
+      end
+
+      it 'raises exception for bad request' do
+        table = Mode::Sdk::Table.new('name', owner: 'owner')
+
+        expect(table).to receive(:validate!)
+        expect(response).to receive(:code).and_return(400)
+        expect(response).to receive(:body)
+        expect(Mode::Sdk::Client).to receive(:post).and_return(response)
+
+        expect {
+          table.send(:upsert, :create)
+        }.to raise_error(Mode::Sdk::Table::InvalidError)
+      end
+    end
+
+    describe 'for replace' do
+      it 'replaces table' do
+        table = Mode::Sdk::Table.new('name', owner: 'owner')
+
+        expect(table).to receive(:validate!)
+        expect(response).to receive(:code).and_return(200)
+        expect(Mode::Sdk::Client).to receive(:put).and_return(response)
+
+        expect(table.send(:upsert, :replace)).to be_an_instance_of(
+          Mode::Sdk::Client::Response)
+      end
+    end
+  end
+
+  describe '#full_name' do
+    it 'forms full name with schema' do
+      table = Mode::Sdk::Table.new('name', owner: 'owner')
+
+      expect(table.full_name).to eq('owner.name')
+    end
+  end
+
+  describe '#upsert_data' do
+    it 'is formed correctly' do
+      table = Mode::Sdk::Table.new('name', owner: 'owner')
+      table.columns = [{ name: 'name', type: 'string' }]
+      table.upload_token = 'token'
+
+      result = table.send(:upsert_data)
+
+      expected = {
+        upload_token: 'token',
+        table: {
+          name:        'name',
+          description: nil,
+          columns:     [{ 'name' => 'name', 'type' => 'string' }]
+        }
+      }
+
+      expect(result).to eq(expected)
+    end
+  end
+
+  describe '#columns=' do
+    it 'unmemoizes column set' do
+      table = Mode::Sdk::Table.new('name', owner: 'owner')
+      table.columns = [{ name: 'name', type: 'string' }]
+      table.send(:column_set)
+
+      expect(table.instance_variable_defined?(:@column_set)).to eq(true)
+
+      table.columns = [{ name: 'name', type: 'string' }]
+
+      expect(table.instance_variable_defined?(:@column_set)).to eq(false)
+    end
+  end
+end

data/spec/lib/mode/sdk/upload_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mode::Sdk::Upload do
+  describe '#create' do
+    it 'performs http post' do
+      upload = Mode::Sdk::Upload.new('content')
+
+      expect(Mode::Sdk::Client).to receive(:post) do |*args|
+        expect(args[0]).to eq('/api/uploads')
+
+        expect(args[1]).to eq('content')
+
+        options = args[2]
+
+        expect(options[:content_type]).to eq('application/csv')
+        expect(options[:content_length]).to eq(7)
+        expect(options[:expect]).to eq([201])
+      end
+
+      upload.create
+    end
+  end
+
+  describe '#token' do
+    it 'retrieves the token' do
+      upload = Mode::Sdk::Upload.new('content')
+
+      response = Mode::Sdk::Client::Response.new(nil)
+      expect(response).to receive(:body).and_return('token' => 'sometoken')
+      expect(upload).to receive(:create).and_return(response)
+
+      expect(upload.token).to eq('sometoken')
+    end
+  end
+end

data/spec/lib/mode/sdk/warehouse_util_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mode::Sdk::WarehouseUtil do
+  let :util do
+    Object.new.extend(Mode::Sdk::WarehouseUtil)
+  end
+
+  describe '#normalize_name' do
+    it 'preserves short name' do
+      expect(util.normalize_name('foo_bar')).to eq('foo_bar')
+    end
+
+    it 'truncates long name' do
+      expect(util.normalize_name('a' * 100).size).to eq(64)
+    end
+  end
+
+  describe '#normalize_string' do
+    it 'preserves simple strings' do
+      %w(foo foo_bar foo_bar_baz).each do |string|
+        expect(util.send(:normalize_string, string)).to eq(string)
+      end
+    end
+
+    it 'normalizes messy strings' do
+      expected = {
+        ' fOO_'                  => 'foo',
+        '_ foo___'               => 'foo',
+        'fo*(*o__BaR ! ?'        => 'foo_bar',
+        'fo__o- _!bar_b _ - az ' => 'fo_o_bar_b_az'
+      }
+
+      expected.each do |input, output|
+        expect(util.send(:normalize_string, input)).to eq(output)
+      end
+    end
+  end
+end

data/spec/lib/mode/sdk_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Mode::Sdk do
+  after :each do
+    Mode::Sdk.reset
+  end
+
+  describe '.configure' do
+    it 'sets configuration variables' do
+      expect_any_instance_of(
+        Mode::Sdk::Configuration).to receive(:setting=).once
+
+      Mode::Sdk.configure do |config|
+        config.setting = 'value'
+      end
+    end
+  end
+
+  describe '.config' do
+    it 'instantiates and memoizes configuration instance' do
+      expect(Mode::Sdk.instance_variable_get(:@config)).to be_nil
+
+      expect(Mode::Sdk.config).to be_an_instance_of(Mode::Sdk::Configuration)
+
+      config = Mode::Sdk.instance_variable_get(:@config)
+
+      expect(config).to be_an_instance_of(Mode::Sdk::Configuration)
+    end
+  end
+
+  describe '.account' do
+    it 'returns account from client' do
+      expect(Mode::Sdk::Client).to receive(:account).and_return(
+        'username' => 'someone')
+
+      expect(Mode::Sdk.account).to eq('username' => 'someone')
+    end
+  end
+
+  describe '.username' do
+    it 'returns username from client' do
+      expect(Mode::Sdk::Client).to receive(:account).and_return(
+        'username' => 'someone')
+
+      expect(Mode::Sdk.username).to eq('someone')
+    end
+  end
+end