perpetuity-postgres 0.0.1

data/spec/perpetuity/postgres/query_union_spec.rb

@@ -0,0 +1,23 @@
+require 'perpetuity/postgres/query_union'
+
+module Perpetuity
+  class Postgres
+    describe QueryUnion do
+      let(:lhs) { double('LHS', to_db: 'left = 1') }
+      let(:rhs) { double('RHS', to_db: 'right = 2') }
+      let(:union) { QueryUnion.new(lhs, rhs) }
+
+      it 'converts to a SQL "OR" expression' do
+        union.to_db.should == '(left = 1 OR right = 2)'
+      end
+
+      it 'allows unions to have other unions' do
+        (union|union).to_db.should == '((left = 1 OR right = 2) OR (left = 1 OR right = 2))'
+      end
+
+      it 'allows unions to have intersections' do
+        (union&union).to_db.should == '((left = 1 OR right = 2) AND (left = 1 OR right = 2))'
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/serialized_data_spec.rb

@@ -0,0 +1,69 @@
+require 'perpetuity/postgres/serialized_data'
+
+module Perpetuity
+  class Postgres
+    describe SerializedData do
+      let(:columns) { [:name, :age] }
+      let(:data) { ["'Jamie'", 31] }
+      let(:serialized) { SerializedData.new(columns, data) }
+
+      it 'matches a SQL string' do
+        serialized.to_s.should == "(name,age) VALUES ('Jamie',31)"
+      end
+
+      describe 'adding values' do
+        it 'adds a value' do
+          serialized['id'] = 'abc'
+          serialized.to_s.should == "(name,age,id) VALUES ('Jamie',31,'abc')"
+        end
+
+        it 'replaces an existing value' do
+          serialized['id'] = 'abc'
+          serialized['id'] = 'xyz'
+          serialized.to_s.should == "(name,age,id) VALUES ('Jamie',31,'xyz')"
+        end
+      end
+
+      context 'with multiple serialized objects' do
+        let(:serialized_multiple) do
+          [ SerializedData.new(columns, ["'Jamie'", 31]),
+            SerializedData.new(columns, ["'Jessica'", 23]),
+            SerializedData.new(columns, ["'Kevin'", 22]),
+          ].reduce(:+)
+        end
+        let(:serialized_multiple) { serialized + SerializedData.new(columns, ["'Jessica'", 23]) +
+                                                 SerializedData.new(columns, ["'Kevin'",22])}
+
+        it 'matches a SQL string' do
+          serialized_multiple.to_s.should == "(name,age) VALUES ('Jamie',31),('Jessica',23),('Kevin',22)"
+        end
+      end
+
+      it 'checks whether there are any objects' do
+        serialized.any?.should be_true
+      end
+
+      it 'iterates like a hash' do
+        serialized.map { |attr, value| [attr, value] }.should ==
+          [['name', "'Jamie'"], ['age', 31]]
+      end
+
+      it 'equals another with the same data' do
+        original = SerializedData.new([:a, :b], [1, 2])
+        duplicate = SerializedData.new([:a, :b], [1, 2])
+        modified = SerializedData.new([:a, :b], [0, 2])
+        original.should == duplicate
+        original.should_not == modified
+      end
+
+      it 'returns a new SerializedData with the complement of values' do
+        columns = [:name, :age, :foo, :bar]
+        original = SerializedData.new(columns, ["'Jamie'", 31, nil, nil])
+        new_name = SerializedData.new(columns, ["'Foo'", 31, nil, nil])
+        new_age = SerializedData.new(columns, ["'Jamie'", 32, nil, nil])
+        (new_name - original).should == SerializedData.new([:name], ["'Foo'"])
+        (new_age - original).should == SerializedData.new([:age], [32])
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/serializer_spec.rb

@@ -0,0 +1,216 @@
+require 'perpetuity/postgres/serializer'
+require 'perpetuity/mapper'
+require 'perpetuity/mapper_registry'
+require 'support/test_classes/book'
+require 'support/test_classes/person'
+
+module Perpetuity
+  class Postgres
+    describe Serializer do
+      let(:registry) { MapperRegistry.new }
+      let!(:book_mapper) do
+        registry = self.registry
+        Class.new(Mapper) do
+          map Book, registry
+          attribute :title, type: String
+          attribute :authors, type: Array[Person], embedded: true
+          attribute :main_character, type: Person
+        end.new(registry)
+      end
+      let!(:person_mapper) do
+        registry = self.registry
+        Class.new(Mapper) do
+          map Person, registry
+          attribute :name, type: String
+        end.new(registry)
+      end
+      let(:serializer) { Serializer.new(book_mapper) }
+
+      it 'serializes simple objects' do
+        serializer.serialize(Book.new('Foo')).to_s.should ==
+          %q{(title,authors,main_character) VALUES ('Foo','[]',NULL)}
+      end
+
+      describe 'serializing complex objects' do
+        let(:jamie) { Person.new('Jamie') }
+        let(:jamie_json) { '{"name":"Jamie","__metadata__":{"class":"Person"}}' }
+        let(:character) { Person.new('Character') }
+        let(:character_json) { '{"__metadata__":{"class":"Person","id":1}}' }
+
+        before { character.instance_variable_set :@id, 1 }
+
+        context 'with nested objects' do
+          let(:book) { Book.new('Foo', jamie, character) }
+          it 'converts objects into JSON' do
+            serializer.serialize(book).to_s.should ==
+              %Q{(title,authors,main_character) VALUES ('Foo','#{jamie_json}','#{character_json}')}
+          end
+        end
+
+        context 'with arrays of nested objects' do
+          let(:book) { Book.new('Foo', [jamie], [character]) }
+
+          it 'adds the JSON array' do
+            serializer.serialize(book).to_s.should ==
+              %Q{(title,authors,main_character) VALUES ('Foo','[#{jamie_json}]','[#{character_json}]')}
+          end
+        end
+      end
+
+      context 'with natively serializable values' do
+        it 'serializes strings' do
+          serializer.serialize_attribute('string').should == "'string'"
+        end
+
+        it 'serializes numbers' do
+          serializer.serialize_attribute(1).should == '1'
+          serializer.serialize_attribute(1.5).should == '1.5'
+        end
+
+        it 'serializes nil' do
+          serializer.serialize_attribute(nil).should == 'NULL'
+        end
+
+        it 'serializes booleans' do
+          serializer.serialize_attribute(true).should == 'TRUE'
+          serializer.serialize_attribute(false).should == 'FALSE'
+        end
+
+        it 'serializes Time objects' do
+          time = Time.new(2000, 1, 2, 3, 4, 5.123456, '-04:00')
+          serializer.serialize_attribute(time).should == "'2000-01-02 03:04:05.123456-0400'::timestamptz"
+        end
+
+        it 'serializes an array as JSON' do
+          serializer.serialize_attribute([1, 'foo']).should == %q{'[1,"foo"]'}
+        end
+      end
+
+      describe 'unserialization AKA deserialization' do
+        let(:author) { Person.new('Me') }
+        let(:serialized_book) do
+          {
+            'id' => 'id-id-id',
+            'title' => 'My Book',
+            'authors' => [
+            ].to_json,
+            'main_character' => nil
+          }
+        end
+
+        it 'deserializes an object that embeds another object' do
+          serialized_authors = [{
+            '__metadata__' => { 'class' => 'Person' },
+            'name' => 'Me'
+          }].to_json
+          serialized_book['authors'] = serialized_authors
+          book = Book.new('My Book', [author])
+          serializer.unserialize(serialized_book).should == book
+        end
+
+        it 'deserializes an object which references another object' do
+          serialized_book['main_character'] = {
+            '__metadata__' => {
+              'class' => 'Person',
+              'id' => 'id-id-id'
+            }
+          }.to_json
+          deserialized_book = Book.new('My Book', [], Reference.new(Person, 'id-id-id'))
+          serializer.unserialize(serialized_book).should == deserialized_book
+        end
+
+        let(:article_class) do
+          Class.new do
+            attr_reader :title, :body, :views, :published_at
+            def initialize attributes={}
+              @title = attributes[:title]
+              @body = attributes[:body]
+              @views = attributes.fetch(:views) { 0 }
+              @published_at = attributes.fetch(:published_at) { Time.now }
+            end
+
+            def == other
+              other.is_a?(self.class) &&
+              other.title == title &&
+              other.body == body &&
+              other.views == views &&
+              other.published_at == published_at
+            end
+          end
+        end
+        let(:article_mapper) do
+          article_class = self.article_class
+          registry = self.registry
+          Class.new(Mapper) do
+            map article_class, registry
+            attribute :title, type: String
+            attribute :body, type: String
+            attribute :views, type: Integer
+            attribute :published_at, type: Time
+          end.new(registry)
+        end
+
+        it 'deserializes non-string attributes to their proper types' do
+          serializer = Serializer.new(article_mapper)
+          serialized_article = {
+            'id' => 'id-id-id',
+            'title' => 'Title',
+            'body' => 'Body',
+            'views' => '0',
+            'published_at' => '2013-01-02 03:04:05.123456-05'
+          }
+
+          article = article_class.new(
+            title: 'Title',
+            body: 'Body',
+            views: 0,
+            published_at: Time.new(2013, 1, 2, 3, 4, 5.123456, '-05:00')
+          )
+          serializer.unserialize(serialized_article).should == article
+        end
+      end
+
+      describe 'identifying embedded/referenced objects as foreign' do
+        it 'sees hashes with metadata keys as foreign objects' do
+          serializer.foreign_object?({'__metadata__' => 'lol'}).should be_true
+        end
+
+        it 'sees hashes without metadata keys as simple hashes' do
+          serializer.foreign_object?({ 'name' => 'foo' }).should be_false
+        end
+      end
+
+      describe 'identifying possible JSON strings' do
+        it 'identifies JSON objects' do
+          serializer.possible_json_value?('{"name":"foo"}').should be_true
+        end
+
+        it 'identifies JSON arrays' do
+          serializer.possible_json_value?('[{"name":"foo"}]').should be_true
+        end
+
+        it 'rejects things it does not detect as either of the above' do
+          serializer.possible_json_value?('foo is my name').should be_false
+        end
+      end
+
+      it 'serializes changes between two objects' do
+        original = Book.new('Old title')
+        modified = original.dup
+        modified.title = 'New title'
+        serializer.serialize_changes(modified, original).should ==
+          SerializedData.new([:title], ["'New title'"])
+      end
+
+      it 'serializes a reference as its referenced class' do
+        reference = Reference.new(Object, 123)
+        serializer.serialize_reference(reference).should == JSONHash.new(
+          __metadata__: {
+            class: Object,
+            id: 123
+          }
+        )
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/sql_select_spec.rb

@@ -0,0 +1,51 @@
+require 'perpetuity/postgres/sql_select'
+
+module Perpetuity
+  class Postgres
+    describe SQLSelect do
+      let(:query) { SQLSelect.new(from: 'foo',
+                                  where: "name = 'foo'",
+                                  limit: 4) }
+      subject { query }
+
+      its(:table) { should == 'foo' }
+      its(:where) { should == "name = 'foo'" }
+      its(:limit) { should == 4 }
+
+      it 'generates a SQL query' do
+        query.to_s.should == %Q{SELECT * FROM "foo" WHERE name = 'foo' LIMIT 4}
+      end
+
+      it 'generates a query with no clauses' do
+        sql = SQLSelect.new(from: 'foo').to_s
+        sql.should == %Q{SELECT * FROM "foo"}
+      end
+
+      it 'generates a count query' do
+        sql = SQLSelect.new('COUNT(*)', from: 'foo').to_s
+        sql.should == %Q{SELECT COUNT(*) FROM "foo"}
+      end
+
+      it 'generates a query with an ORDER BY clause' do
+        sql = SQLSelect.new(from: 'foo', order: 'name').to_s
+        sql.should == %Q{SELECT * FROM "foo" ORDER BY name}
+
+        sql = SQLSelect.new(from: 'foo', order: { name: :asc }).to_s
+        sql.should == %Q{SELECT * FROM "foo" ORDER BY name ASC}
+
+        sql = SQLSelect.new(from: 'foo', order: { name: :asc, age: :desc }).to_s
+        sql.should == %Q{SELECT * FROM "foo" ORDER BY name ASC,age DESC}
+      end
+
+      it 'generates a query with an OFFSET clause' do
+        sql = SQLSelect.new(from: 'foo', offset: 12).to_s
+        sql.should == %Q{SELECT * FROM "foo" OFFSET 12}
+      end
+
+      it 'generates a query with a GROUP BY clause' do
+        sql = SQLSelect.new(from: 'foo', group: :id).to_s
+        sql.should == %Q{SELECT * FROM "foo" GROUP BY id}
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/sql_update_spec.rb

@@ -0,0 +1,22 @@
+require 'perpetuity/postgres/sql_update'
+require 'perpetuity/postgres/serialized_data'
+
+module Perpetuity
+  class Postgres
+    describe SQLUpdate do
+      context 'when given a SerializedData' do
+        it 'generates the SQL to update an object' do
+          update = SQLUpdate.new('User', 'abc123', SerializedData.new([:foo, :baz], ["'bar'", "'quux'"]))
+          update.to_s.should == %Q{UPDATE "User" SET foo = 'bar',baz = 'quux' WHERE id = 'abc123'}
+        end
+      end
+
+      context 'when given a hash' do
+        it 'sanitizes the data into SQLValues' do
+          update = SQLUpdate.new('User', 'abc123', foo: 'bar', baz: 'quux')
+          update.to_s.should == %Q{UPDATE "User" SET foo = 'bar',baz = 'quux' WHERE id = 'abc123'}
+        end
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/sql_value_spec.rb

@@ -0,0 +1,38 @@
+require 'perpetuity/postgres/sql_value'
+
+module Perpetuity
+  class Postgres
+    describe SQLValue do
+      it 'converts strings' do
+        SQLValue.new('Foo').should == "'Foo'"
+        SQLValue.new("Jamie's House").should == "'Jamie''s House'"
+      end
+
+      it 'converts symbols' do
+        SQLValue.new(:foo).should == "'foo'"
+      end
+
+      it 'converts integers' do
+        SQLValue.new(1).should == "1"
+      end
+
+      it 'converts floats' do
+        SQLValue.new(1.5).should == "1.5"
+      end
+
+      it 'converts nil' do
+        SQLValue.new(nil).should == "NULL"
+      end
+
+      it 'converts booleans' do
+        SQLValue.new(true).should == "TRUE"
+        SQLValue.new(false).should == "FALSE"
+      end
+
+      it 'converts Time objects' do
+        time = Time.new(2013, 1, 2, 3, 4, 5.1234567, '+05:30')
+        SQLValue.new(time).should == "'2013-01-02 03:04:05.123456+0530'::timestamptz"
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/table/attribute_spec.rb

@@ -0,0 +1,82 @@
+require 'perpetuity/postgres/table/attribute'
+require 'perpetuity/postgres/expression'
+
+module Perpetuity
+  class Postgres
+    class Table
+      describe Attribute do
+        let(:title)  { Attribute.new('title', String, max_length: 40) }
+
+        it 'knows its name' do
+          title.name.should == 'title'
+        end
+
+        it 'knows its type' do
+          title.type.should == String
+        end
+
+        describe 'id' do
+          let(:id) do
+            Attribute.new('id', Attribute::UUID,
+                          primary_key: true,
+                          default: Expression.new('uuid_generate_v4()')
+                         )
+          end
+
+          it 'is a UUID type' do
+            id.sql_type.should == 'UUID'
+          end
+
+          it 'is a primary key' do
+            id.should be_primary_key
+          end
+
+          it 'can have a specified default' do
+            id.default.should == Expression.new('uuid_generate_v4()')
+          end
+
+          it 'generates the proper SQL' do
+            id.sql_declaration.should == 'id UUID PRIMARY KEY DEFAULT uuid_generate_v4()'
+          end
+        end
+
+        describe 'strings' do
+          let(:body) { Attribute.new('body', String, default: 'foo') }
+
+          it 'converts to the proper SQL type' do
+            title.sql_type.should == 'VARCHAR(40)'
+            body.sql_type.should == 'TEXT'
+          end
+
+          it 'generates the proper SQL' do
+            body.sql_declaration.should == "body TEXT DEFAULT 'foo'"
+          end
+        end
+
+        describe 'integers' do
+          let(:page_views) { Attribute.new('page_views', Integer, default: 0) }
+
+          it 'generates the proper SQL' do
+            page_views.sql_declaration.should == 'page_views INTEGER DEFAULT 0'
+          end
+        end
+
+        describe 'times' do
+          let(:timestamp) { Attribute.new('timestamp', Time) }
+
+          it 'converts to the SQL TIMESTAMPTZ type' do
+            timestamp.sql_type.should == 'TIMESTAMPTZ'
+          end
+        end
+
+        describe 'non-serializable types' do
+          let(:author) { Attribute.new('author', Object) }
+
+          it 'has an SQL type of JSON' do
+            author.sql_type.should == 'JSON'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/table_name_spec.rb

@@ -0,0 +1,15 @@
+require 'perpetuity/postgres/table_name'
+
+module Perpetuity
+  class Postgres
+    describe TableName do
+      it 'converts to a SQL-string table name' do
+        TableName.new('Person').to_s.should == '"Person"'
+      end
+
+      it 'compares equally to its string representation' do
+        TableName.new('Person').should == 'Person'
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/table_spec.rb

@@ -0,0 +1,43 @@
+require 'perpetuity/postgres/table'
+require 'perpetuity/postgres/table/attribute'
+
+module Perpetuity
+  class Postgres
+    describe Table do
+      let(:title)  { Table::Attribute.new('title', String, max_length: 40) }
+      let(:body)   { Table::Attribute.new('body', String) }
+      let(:author) { Table::Attribute.new('author', Object) }
+      let(:published_at) { Table::Attribute.new('published_at', Time) }
+      let(:views) { Table::Attribute.new('views', Integer) }
+      let(:attributes) { [title, body, author, published_at, views] }
+      let(:table) { Table.new('Article', attributes) }
+
+      it 'knows its name' do
+        table.name.should == 'Article'
+      end
+
+      it 'knows its attributes' do
+        table.attributes.should == attributes
+      end
+
+      it 'converts to a string for SQL' do
+        table.to_s.should == '"Article"'
+      end
+
+      it 'generates proper SQL to create itself' do
+        table.create_table_sql.should ==
+          'CREATE TABLE IF NOT EXISTS "Article" (id UUID PRIMARY KEY DEFAULT uuid_generate_v4(), title VARCHAR(40), body TEXT, author JSON, published_at TIMESTAMPTZ, views INTEGER)'
+      end
+
+      describe 'id column' do
+        context 'when there is an id attribute' do
+          it 'uses the attribute type for the column type' do
+            attributes = [Table::Attribute.new(:id, String, primary_key: true), Table::Attribute.new(:name, String)]
+            table = Table.new('User', attributes)
+            table.create_table_sql.should == 'CREATE TABLE IF NOT EXISTS "User" (id TEXT PRIMARY KEY, name TEXT)'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/text_value_spec.rb

@@ -0,0 +1,15 @@
+require 'perpetuity/postgres/text_value'
+
+module Perpetuity
+  class Postgres
+    describe TextValue do
+      it 'serializes into a Postgres-compatible string' do
+        TextValue.new('Jamie').to_s.should == "'Jamie'"
+      end
+
+      it 'escapes single quotes' do
+        TextValue.new("Jamie's house").to_s.should == "'Jamie''s house'"
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/timestamp_value_spec.rb

@@ -0,0 +1,28 @@
+require 'perpetuity/postgres/timestamp_value'
+
+module Perpetuity
+  class Postgres
+    describe TimestampValue do
+      it 'converts to a SQL string' do
+        time = Time.new(2000, 1, 2, 3, 4, 5.0123456, '-04:00')
+        TimestampValue.new(time).to_s.should == "'2000-01-02 03:04:05.012345-0400'::timestamptz"
+      end
+
+      describe 'conversion from a SQL value string' do
+        it 'converts GMT-X times' do
+          timestamp = TimestampValue.from_sql('2013-12-01 15:31:23.838367-05')
+          timestamp.to_time.should == Time.new(2013, 12, 1, 15, 31, 23.838367, '-05:00')
+        end
+
+        it 'converts GMT+X times' do
+          timestamp = TimestampValue.from_sql('1982-08-25 22:19:10.123456+08')
+          timestamp.to_time.should == Time.new(1982, 8, 25, 10, 19, 10.123456, '-04:00')
+        end
+      end
+
+      it 'returns its wrapped value' do
+        TimestampValue.new(:foo).value.should == :foo
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/value_with_attribute_spec.rb

@@ -0,0 +1,34 @@
+require 'perpetuity/postgres/value_with_attribute'
+
+module Perpetuity
+  class Postgres
+    describe ValueWithAttribute do
+      let(:attribute) { OpenStruct.new(name: :name, type: String) }
+      let(:serialized) { ValueWithAttribute.new('foo', attribute) }
+
+      it 'contains a value and an attribute' do
+        serialized.value.should == 'foo'
+        serialized.attribute.should == attribute
+      end
+
+      it 'knows its type' do
+        serialized.type.should be String
+      end
+
+      context 'when attribute is embedded' do
+        let(:attribute) { OpenStruct.new(embedded?: true) }
+        it 'is embedded' do
+          serialized.should be_embedded
+        end
+      end
+
+      context 'when attribute is not embedded' do
+        let(:attribute) { OpenStruct.new(embedded?: false) }
+
+        it 'is not embedded' do
+          serialized.should_not be_embedded
+        end
+      end
+    end
+  end
+end