terrestrial 0.1.0 → 0.1.1

data/spec/support/object_graph_setup.rb

@@ -0,0 +1,139 @@
+require "terrestrial/serializer"
+require "terrestrial/struct_factory"
+
+RSpec.shared_context "object graph setup" do
+
+  before do
+    setup_circular_references_avoiding_stack_overflow
+  end
+
+  def setup_circular_references_avoiding_stack_overflow
+    biscuits_post_comment.commenter = hansel
+    cat_biscuits_category.posts = [ biscuits_post ]
+  end
+
+  class PlainObject
+    def self.with_members(*list, &block)
+      Class.new(self).tap { |klass|
+        klass.instance_variable_set(:@members, list)
+        klass.class_exec(&block) if block
+        klass.send(:attr_accessor, *list)
+      }
+    end
+
+    def self.members
+      @members
+    end
+
+    def initialize(attrs)
+      members.sort == attrs.keys.sort or (
+        raise(ArgumentError.new("Expected `#{self.class.members}` got `#{attrs.keys}"))
+      )
+
+      members.each { |member| send("#{member}=", attrs.fetch(member)) }
+    end
+
+    def members
+      self.class.members
+    end
+
+    def to_h
+      Hash[members.map { |field| [field, send(field)] }]
+    end
+  end
+
+  User ||= PlainObject.with_members(:id, :first_name, :last_name, :email, :posts)
+  Post ||= PlainObject.with_members(:id, :subject, :body, :comments, :categories, :created_at)
+  Comment ||= PlainObject.with_members(:id, :commenter, :body)
+  Category ||= PlainObject.with_members(:id, :name, :posts)
+
+  let(:factories) {
+    {
+      users: User.method(:new),
+      posts: Post.method(:new),
+      comments: Comment.method(:new),
+      categories: Category.method(:new),
+      categories_to_posts: ->(x){x},
+      noop: ->(x){x},
+    }
+  }
+
+  let(:default_serializer) {
+    ->(fields) {
+      ->(object) {
+        Terrestrial::Serializer.new(fields, object).to_h
+      }
+    }
+  }
+
+  let(:null_serializer) {
+    ->(_fields) {
+      ->(x){x}
+    }
+  }
+
+  let(:hansel) {
+    factories.fetch(:users).call(
+      id: "users/1",
+      first_name: "Hansel",
+      last_name: "Trickett",
+      email: "hansel@tricketts.org",
+      posts: [
+        biscuits_post,
+        sleep_post,
+      ],
+    )
+  }
+
+  let(:biscuits_post) {
+    factories.fetch(:posts).call(
+      id: "posts/1",
+      subject: "Biscuits",
+      body: "I like them",
+      comments: [
+        biscuits_post_comment,
+      ],
+      categories: [
+        cat_biscuits_category,
+      ],
+      created_at: Time.parse("2015-09-05T15:00:00+01:00"),
+    )
+  }
+
+  let(:sleep_post) {
+    factories.fetch(:posts).call(
+      id: "posts/2",
+      subject: "Sleeping",
+      body: "I do it three times purrr day",
+      comments: [],
+      categories: [
+        chilling_category,
+      ],
+      created_at: Time.parse("2015-09-02T15:00:00+01:00"),
+    )
+  }
+
+  let(:biscuits_post_comment) {
+    factories.fetch(:comments).call(
+      id: "comments/1",
+      body: "oh noes",
+      commenter: nil,
+    )
+  }
+
+  let(:cat_biscuits_category) {
+    factories.fetch(:categories).call(
+      id: "categories/1",
+      name: "Cat biscuits",
+      posts: [],
+    )
+  }
+
+  let(:chilling_category) {
+    factories.fetch(:categories).call(
+      id: "categories/2",
+      name: "Chillaxing",
+      posts: [],
+    )
+  }
+end

data/spec/support/seed_data_setup.rb

@@ -0,0 +1,165 @@
+require "support/object_graph_setup"
+RSpec.shared_context "seed data setup" do
+  include_context "object graph setup"
+
+  before {
+    insert_records(datastore, seeded_records)
+  }
+
+  let(:seeded_records) {
+    [
+      [ :users, hansel_record ],
+      [ :users, jasper_record ],
+      [ :users, poppy_record ],
+      [ :posts, biscuits_post_record ],
+      [ :posts, sleep_post_record ],
+      [ :posts, catch_frogs_post_record ],
+      [ :posts, chew_up_boxes_post_record ],
+      [ :comments, biscuits_post_comment_record ],
+      [ :categories, cat_biscuits_category_record ],
+      [ :categories, eating_and_sleeping_category_record ],
+      [ :categories, hunting_category_record ],
+      [ :categories, messing_stuff_up_category_record ],
+      *categories_to_posts_records.map { |record|
+        [ :categories_to_posts, record ]
+      },
+    ]
+  }
+
+  let(:hansel_record) {
+    {
+      id: "users/1",
+      first_name: "Hansel",
+      last_name: "Trickett",
+      email: "hansel@tricketts.org",
+    }
+  }
+
+  let(:jasper_record) {
+    {
+      id: "users/2",
+      first_name: "Jasper",
+      last_name: "Trickett",
+      email: "jasper@tricketts.org",
+    }
+  }
+
+  let(:poppy_record) {
+    {
+      id: "users/3",
+      first_name: "Poppy",
+      last_name: "Herzog",
+      email: "poppy@herzog.info",
+    }
+  }
+
+  let(:biscuits_post_record) {
+    {
+      id: "posts/1",
+      subject: "Biscuits",
+      body: "I like them",
+      author_id: "users/1",
+      created_at: Time.parse("2015-09-05T15:00:00+01:00"),
+    }
+  }
+
+  let(:sleep_post_record) {
+    {
+      id: "posts/2",
+      subject: "Sleeping",
+      body: "I do it three times purrr day",
+      author_id: "users/1",
+      created_at: Time.parse("2015-09-02T15:00:00+01:00"),
+    }
+  }
+
+  let(:catch_frogs_post_record) {
+    {
+      id: "posts/3",
+      subject: "Catching frongs",
+      body: "I love them while at the same time I hate them",
+      author_id: "users/2",
+      created_at: Time.parse("2015-09-03T15:00:00+01:00"),
+    }
+  }
+
+  let(:chew_up_boxes_post_record) {
+    {
+      id: "posts/4",
+      subject: "Chewing up boxes",
+      body: "I love them, and yet I destory them",
+      author_id: "users/2",
+      created_at: Time.parse("2015-09-10T11:00:00+01:00"),
+    }
+  }
+
+  let(:biscuits_post_comment_record) {
+    {
+      id: "comments/1",
+      body: "oh noes",
+      post_id: "posts/1",
+      commenter_id: "users/1",
+    }
+  }
+
+  let(:cat_biscuits_category_record) {
+    {
+      id: "categories/1",
+      name: "Cat biscuits",
+    }
+  }
+
+  let(:eating_and_sleeping_category_record) {
+    {
+      id: "categories/2",
+      name: "Eating and sleeping",
+    }
+  }
+
+  let(:hunting_category_record) {
+    {
+      id: "categories/3",
+      name: "Hunting",
+    }
+  }
+
+  let(:messing_stuff_up_category_record) {
+    {
+      id: "categories/4",
+      name: "Messing stuff up",
+    }
+  }
+
+  let(:categories_to_posts_records) {
+    [
+      {
+        post_id: "posts/1",
+        category_id: "categories/1",
+      },
+      {
+        post_id: "posts/1",
+        category_id: "categories/2",
+      },
+      {
+        post_id: "posts/2",
+        category_id: "categories/2",
+      },
+      {
+        post_id: "posts/3",
+        category_id: "categories/2",
+      },
+      {
+        post_id: "posts/3",
+        category_id: "categories/3",
+      },
+      {
+        post_id: "posts/4",
+        category_id: "categories/3",
+      },
+      {
+        post_id: "posts/4",
+        category_id: "categories/4",
+      },
+    ]
+  }
+end

data/spec/support/sequel_persistence_setup.rb

@@ -0,0 +1,19 @@
+require "support/sequel_test_support"
+
+RSpec.shared_context "sequel persistence setup" do
+  include Terrestrial::SequelTestSupport
+
+  before { truncate_tables }
+
+  let(:datastore) {
+    db_connection.tap { |db|
+      # The query_counter will let us make assertions about how efficiently
+      # the database is being used
+      db.loggers << query_counter
+    }
+  }
+
+  let(:query_counter) {
+    Terrestrial::SequelTestSupport::QueryCounter.new
+  }
+end

data/spec/support/sequel_test_support.rb

@@ -0,0 +1,166 @@
+require "sequel"
+
+module Terrestrial
+  module SequelTestSupport
+    def create_database
+      `psql postgres --command "CREATE DATABASE $PGDATABASE;"`
+    end
+    module_function :create_database
+
+    def drop_database
+      `psql postgres --command "DROP DATABASE $PGDATABASE;"`
+    end
+    module_function :drop_database
+
+    def drop_tables(tables = db_connection.tables)
+      tables.each do |table_name|
+        db_connection.drop_table(table_name, cascade: true)
+      end
+    end
+    module_function :drop_tables
+
+    def truncate_tables(tables = db_connection.tables)
+      tables.each do |table_name|
+        db_connection[table_name].truncate(cascade: true)
+      end
+    end
+    module_function :truncate_tables
+
+    def db_connection
+      Sequel.default_timezone = :utc
+      @db_connection ||= Sequel.postgres(
+        host: ENV.fetch("PGHOST"),
+        user: ENV.fetch("PGUSER"),
+        database: ENV.fetch("PGDATABASE"),
+      )
+    end
+    module_function :db_connection
+
+    def create_tables(schema)
+      schema.fetch(:tables).each do |table_name, fields|
+        db_connection.create_table(table_name) do
+          fields.each do |field|
+            type = field.fetch(:type)
+            name = field.fetch(:name)
+            options = field.fetch(:options, {})
+
+            column(name, type, options)
+          end
+        end
+      end
+
+      schema.fetch(:foreign_keys).each do |(table, fk_col, foreign_table, key_col)|
+        db_connection.alter_table(table) do
+          add_foreign_key([fk_col], foreign_table, key: key_col, deferrable: false, on_delete: :set_null)
+        end
+      end
+
+      schema.fetch(:tables).keys
+    end
+    module_function :create_tables
+
+    def insert_records(datastore, records)
+      records.each { |(namespace, record)|
+        datastore[namespace].insert(record)
+      }
+    end
+
+    class QueryCounter
+      def initialize
+        reset
+      end
+
+      def read_count
+        read_count_with_describes -
+          list_tables_query_count -
+          describe_table_queries_count
+      end
+
+      def delete_count
+        @info.count { |query|
+          /\A\([0-9\.]+s\) DELETE/i === query
+        }
+      end
+
+      def read_count_with_describes
+        @info.count { |query|
+          /\A\([0-9\.]+s\) SELECT/i === query
+        }
+      end
+
+      def update_count
+        updates.count
+      end
+
+      def updates
+        @info
+          .map { |query| query.gsub(/\A\([0-9\.]+s\) /, "") }
+          .select { |query| query.start_with?("UPDATE") }
+      end
+
+      def show_queries
+        puts @info.join("\n")
+      end
+
+      def info(message)
+        @info.push(message)
+      end
+
+      def error(message)
+        @error.push(message)
+      end
+
+      def warn(message)
+        @warn.push(message)
+      end
+
+      def reset
+        @described_table_queries = []
+        @info = []
+        @error = []
+        @warn = []
+      end
+
+      private
+
+      def list_tables_query_count
+        @info.count { |query| list_tables_query_pattern.match(query) }
+      end
+
+      def describe_table_queries_count
+        describe_table_queries.count
+      end
+
+      def describe_table_queries
+        # TODO this could probably be better solved with finite automata
+        described_table_queries = []
+
+        queries_without_table_list
+          .take_while { |query|
+            described_table_queries.push(query)
+            described_table_query_pattern.match(query) &&
+              described_table_queries.length == described_table_queries.uniq.length
+          }
+      end
+
+      def queries_without_table_list
+        @info
+          .drop_while { |query|
+            !list_tables_query_pattern.match(query)
+          }
+          .drop_while { |query|
+            list_tables_query_pattern.match(query)
+          }
+      end
+
+
+      def list_tables_query_pattern
+        /\A\([0-9\.]+s\) SELECT "relname" FROM "pg_class"/
+      end
+
+      def described_table_query_pattern
+        /\A\([0-9\.]+s\) SELECT \* FROM "[^"]+" LIMIT 1/i
+      end
+    end
+  end
+end