jets 0.5.0 → 0.5.1

data/vendor/dynomite/lib/dynomite/migration/templates/create_table.rb

@@ -0,0 +1,32 @@
+class <%= @migration_class_name %> < Dynomite::Migration
+  def up
+    create_table :<%= @table_name %> do |t|
+      t.partition_key "<%= @partition_key %>" # required
+<% if @sort_key # so extra spaces are not added when generated -%>
+      t.sort_key  "<%= @sort_key %>" # optional
+<% end -%>
+      t.provisioned_throughput(<%= @provisioned_throughput %>) # sets both read and write, defaults to 5 when not set
+
+      # Instead of using partition_key and sort_key you can set the
+      # key schema directly also
+      # t.key_schema([
+      #     {attribute_name: "id", :key_type=>"HASH"},
+      #     {attribute_name: "created_at", :key_type=>"RANGE"}
+      #   ])
+      # t.attribute_definitions([
+      #   {attribute_name: "id", attribute_type: "N"},
+      #   {attribute_name: "created_at", attribute_type: "S"}
+      # ])
+
+      # other ways to set provisioned_throughput
+      # t.provisioned_throughput(:read, 10)
+      # t.provisioned_throughput(:write, 10)
+      # t.provisioned_throughput(
+      #   read_capacity_units: 5,
+      #   write_capacity_units: 5
+      # )
+    end
+  end
+end
+
+# More examples: https://github.com/tongueroo/dynomite/tree/master/docs

data/vendor/dynomite/lib/dynomite/migration/templates/update_table.rb

@@ -0,0 +1,26 @@
+class <%= @migration_class_name %> < Dynomite::Migration
+  def up
+    update_table :<%= @table_name %> do |t|
+      t.gsi(:create) do |i|
+        i.partition_key "<%= @partition_key %>" # required
+<% if @sort_key # so extra spaces are not added when generated -%>
+        t.sort_key  "<%= @sort_key %>" # optional
+<% end -%>
+
+        i.provisioned_throughput(5)
+      end
+
+      # Examples:
+      # t.gsi(:update, "update-me-index") do |i|
+      #   i.provisioned_throughput(10)
+      # end
+
+      # t.gsi(:delete, "delete-me-index")
+
+      # Must use :create, :update, :delete one at a time in separate migration files.
+      # DynamoDB imposes this.
+    end
+  end
+end
+
+# More examples: https://github.com/tongueroo/dynomite/tree/master/docs

data/vendor/dynomite/lib/dynomite/version.rb

@@ -0,0 +1,3 @@
+module Dynomite
+  VERSION = "1.0.7"
+end

data/vendor/dynomite/spec/fixtures/app_root/config/dynamodb.yml

@@ -0,0 +1,7 @@
+# Throwing this in here to make tests easier to write
+development:
+  endpoint: http://localhost:8000
+
+test:
+  table_namespace: 'testnamespace'
+  endpoint: http://localhost:8000

data/vendor/dynomite/spec/lib/dynomite/item_spec.rb

@@ -0,0 +1,89 @@
+require "spec_helper"
+
+class Post < Dynomite::Item
+end
+class Comment < Dynomite::Item
+  partition_key "post_id" # defaults to id
+end
+
+describe Dynomite::Item do
+  describe "general" do
+    it "loads attributes" do
+      post = Post.new(title: "my title", desc: "my desc")
+      expect(post.attrs).to eq("title" => "my title", "desc" => "my desc")
+
+      post.attrs(title: "my title2")
+      expect(post.attrs).to eq("title" => "my title2", "desc" => "my desc")
+    end
+
+    it "table_name" do
+      expect(Post.table_name).to eq "testnamespace-posts"
+      expect(Comment.table_name).to eq "testnamespace-comments"
+      # hack to quickly test blank and namespaces
+      old_namespace = Comment.instance_variable_get(:@table_namespace)
+      Comment.instance_variable_set(:@table_namespace, '')
+      expect(Comment.table_name).to eq "comments"
+      Comment.instance_variable_set(:@table_namespace, old_namespace)
+    end
+
+    it "partition_key" do
+      expect(Post.partition_key).to eq "id"
+      expect(Comment.partition_key).to eq "post_id"
+    end
+  end
+
+  describe "CRUD-ish" do
+    before(:each) { Post.db = db }
+    let(:db) { double(:db) }
+
+    let(:find_resp) do
+      fake_attributes = {"id" => "myid", "title" => "my title"}
+      resp = double(:resp)
+      expect(resp).to receive(:item).and_return(fake_attributes)
+      resp
+    end
+    it "find" do
+      expect(Post.db).to receive(:get_item).and_return(find_resp)
+
+      post = Post.find("myid")
+
+      expect(post.attrs).to eq("id" => "myid", "title" => "my title")
+    end
+
+    it "replace" do
+      # Not returning a resp with receive because it is not useful
+      # Dynanmodb doesnt provide much useful info there.
+      expect(Post.db).to receive(:put_item)
+
+      post = Post.new(title: "my title")
+      post.replace
+      attrs = post.attrs
+
+      expect(attrs[:title]).to eq "my title"
+      expect(attrs[:id].size).to eq 40 # generated unique id
+    end
+
+    it "delete" do
+      allow(Post.db).to receive(:delete_item)
+
+      Post.delete("myid")
+
+      expect(Post.db).to have_received(:delete_item)
+    end
+
+    let(:scan_resp) do
+      fake_attributes = [{"id" => "myid", "title" => "my title"}]
+      resp = double(:resp)
+      expect(resp).to receive(:items).and_return(fake_attributes)
+      resp
+    end
+    it "scan" do
+      allow(Post.db).to receive(:scan).and_return(scan_resp)
+
+      post = Post.scan
+
+      expect(Post.db).to have_received(:scan)
+    end
+  end
+end
+

data/vendor/dynomite/spec/lib/dynomite/migration/dsl/global_secondary_index_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper"
+
+GSI = Dynomite::Migration::Dsl::GlobalSecondaryIndex
+
+describe GSI do
+  context "create index" do
+    let(:index) do
+      Dynomite::Migration::Dsl.db = double("db").as_null_object
+      GSI.new(:create)
+    end
+
+    # Supports this DSL, the `i` variable passed to the block is the
+    # Dsl::GlobalSecondaryIndex instance
+    #
+    # class UpdateCommentsMigration < Dynomite::Migration
+    #   def up
+    #     update_table :comments do |t|
+    #       t.partition_key "post_id:string" # required
+    #       t.sort_key  "created_at:string" # optional
+    #       t.provisioned_throughput(5) # sets both read and write
+    #     end
+    #   end
+    # end
+    it "build up the dsl in memory" do
+      index.partition_key "id:string" # required
+      index.sort_key  "created_at:string" # optional
+      index.provisioned_throughput(30)
+
+      expect(index.key_schema).to eq([
+        {:attribute_name=>"id", :key_type=>"HASH"},
+        {:attribute_name=>"created_at", :key_type=>"RANGE"}])
+      expect(index.attribute_definitions).to eq([
+        {:attribute_name=>"id", :attribute_type=>"S"},
+        {:attribute_name=>"created_at", :attribute_type=>"S"}])
+      expect(index.provisioned_throughput).to eq(
+        :read_capacity_units=>30,
+        :write_capacity_units=>30
+      )
+    end
+
+    context "parititon_key provided only" do
+      it "index_name" do
+        index.partition_key "post_id:string" # required
+        expect(index.params[:index_name]).to eq("post_id-index")
+      end
+    end
+
+    context "parititon_key and sort_key provided" do
+      it "index_name" do
+        index.partition_key "post_id:string" # required
+        index.sort_key  "created_at:string" # optional
+        expect(index.params[:index_name]).to eq("post_id-created_at-index")
+
+        expect(index.params).to eq({
+          :index_name=>"post_id-created_at-index",
+          :key_schema=>[
+            {:attribute_name=>"post_id", :key_type=>"HASH"},
+            {:attribute_name=>"created_at", :key_type=>"RANGE"}],
+          :projection=>{:projection_type=>"ALL"},
+          :provisioned_throughput=> {:read_capacity_units=>5, :write_capacity_units=>5}
+        })
+      end
+    end
+
+    it "execute uses what the dsl methods built up in memory and translates it dynmaodb params that then get used to execute and run the command" do
+      index.partition_key "id:string" # required
+      index.sort_key  "created_at:string" # optional
+      index.provisioned_throughput(30)
+      # index.execute # TODO: index.execute in here
+    end
+  end
+
+  context "update index" do
+    let(:index) do
+      Dynomite::Migration::Dsl.db = double("db").as_null_object
+      GSI.new(:update) do |i|
+        i.index_name = "update-me-index"
+      end
+    end
+
+    it "only sets the index_name and provisioned_throughput params keys" do
+      index.provisioned_throughput(8)
+      params = index.params
+      expect(params[:provisioned_throughput]).to eq({:read_capacity_units=>8, :write_capacity_units=>8})
+      expect(params[:index_name]).not_to be nil
+      expect(params[:key_schema]).to be nil
+      expect(params[:projection]).to be nil
+    end
+  end
+
+  context "delete index" do
+    let(:index) do
+      Dynomite::Migration::Dsl.db = double("db").as_null_object
+      GSI.new(:delete, "delete-me-index")
+    end
+
+    it "only sets the index_name" do
+      index.provisioned_throughput(8)
+      params = index.params
+      expect(params[:index_name]).not_to be nil
+      expect(params[:provisioned_throughput]).to be nil
+      expect(params[:key_schema]).to be nil
+      expect(params[:projection]).to be nil
+    end
+  end
+end

data/vendor/dynomite/spec/lib/dynomite/migration/dsl/local_secondary_index_spec.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+
+LSI = Dynomite::Migration::Dsl::LocalSecondaryIndex
+
+describe LSI do
+  context "create index" do
+    let(:index) do
+      Dynomite::Migration::Dsl.db = double("db").as_null_object
+      LSI.new
+    end
+
+    # Supports this DSL, the `i` variable passed to the block is the
+    # Dsl::GlobalSecondaryIndex instance
+    #
+    # class UpdateCommentsMigration < Dynomite::Migration
+    #   def up
+    #     update_table :comments do |t|
+    #       t.partition_key "post_id:string" # required
+    #       t.sort_key  "created_at:string" # optional
+    #       t.provisioned_throughput(5) # sets both read and write
+    #     end
+    #   end
+    # end
+    it "build up the dsl in memory" do
+      index.partition_key "id:string" # required
+      index.sort_key  "created_at:string" # optional
+      index.provisioned_throughput(30)
+
+      expect(index.key_schema).to eq([
+        {:attribute_name=>"id", :key_type=>"HASH"},
+        {:attribute_name=>"created_at", :key_type=>"RANGE"}])
+      expect(index.attribute_definitions).to eq([
+        {:attribute_name=>"id", :attribute_type=>"S"},
+        {:attribute_name=>"created_at", :attribute_type=>"S"}])
+      expect(index.provisioned_throughput).to eq(
+        :read_capacity_units=>30,
+        :write_capacity_units=>30
+      )
+    end
+
+    context "parititon_key provided only" do
+      it "index_name" do
+        index.partition_key "post_id:string" # required
+        expect(index.params[:index_name]).to eq("post_id-index")
+      end
+    end
+
+    context "parititon_key and sort_key provided" do
+      it "index_name" do
+        index.partition_key "post_id:string" # required
+        index.sort_key  "created_at:string" # optional
+        expect(index.params[:index_name]).to eq("post_id-created_at-index")
+
+        expect(index.params).to eq({
+          :index_name=>"post_id-created_at-index",
+          :key_schema=>[
+            {:attribute_name=>"post_id", :key_type=>"HASH"},
+            {:attribute_name=>"created_at", :key_type=>"RANGE"}],
+          :projection=>{:projection_type=>"ALL"},
+          :provisioned_throughput=> {:read_capacity_units=>5, :write_capacity_units=>5}
+        })
+      end
+    end
+
+    it "execute uses what the dsl methods built up in memory and translates it dynmaodb params that then get used to execute and run the command" do
+      index.partition_key "id:string" # required
+      index.sort_key  "created_at:string" # optional
+      index.provisioned_throughput(30)
+      # index.execute # TODO: index.execute in here
+    end
+  end
+end

data/vendor/dynomite/spec/lib/dynomite/migration/dsl_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+
+describe Dynomite::Migration::Dsl do
+  # Supports this DSL, the `t` variable passed to the block is the Dsl instance
+  #
+  # class CreateCommentsMigration < Dynomite::Migration
+  #   def up
+  #     create_table :comments do |t|
+  #       t.partition_key "post_id:string" # required
+  #       t.sort_key  "created_at:string" # optional
+  #       t.provisioned_throughput(5) # sets both read and write, defaults to 5 when not set
+  #     end
+  #   end
+  # end
+  context "create_table" do
+    let(:dsl) do
+      Dynomite::Migration::Dsl.db = double("db").as_null_object
+      Dynomite::Migration::Dsl.new(:create_table, "posts")
+    end
+
+    it "build up the dsl in memory" do
+      dsl.partition_key "id:string" # required
+      dsl.sort_key  "created_at:string" # optional
+      dsl.provisioned_throughput(25)
+
+      expect(dsl.key_schema).to eq([
+        {:attribute_name=>"id", :key_type=>"HASH"},
+        {:attribute_name=>"created_at", :key_type=>"RANGE"}])
+      expect(dsl.attribute_definitions).to eq([
+        {:attribute_name=>"id", :attribute_type=>"S"},
+        {:attribute_name=>"created_at", :attribute_type=>"S"}])
+      expect(dsl.provisioned_throughput).to eq(
+        :read_capacity_units=>25,
+        :write_capacity_units=>25
+      )
+    end
+  end
+
+  context "update_table" do
+    let(:dsl) do
+      Dynomite::Migration::Dsl.db = double("db").as_null_object
+      Dynomite::Migration::Dsl.new(:update_table, "comments")
+    end
+
+    it "builds up the gsi index params" do
+      dsl.provisioned_throughput(18)
+
+      dsl.gsi(:create) do |i|
+        i.partition_key "post_id:string"
+        i.sort_key "updated_at:string" # optional
+      end
+      dsl.gsi(:update, "another-index") do |i|
+        i.provisioned_throughput(8)
+      end
+      dsl.gsi(:delete, "old-index")
+
+      params = dsl.params
+      # pp params # uncomment out to inspect params
+      # attribute_definitions is a Double because we've mocked out:
+      # Dynomite::Migration::Dsl.db = double("db").as_null_object
+      expect(params.key?(:attribute_definitions)).to be true
+      expect(params.key?(:global_secondary_index_updates)).to be true
+      global_secondary_index_updates = params[:global_secondary_index_updates]
+      index_actions = global_secondary_index_updates.map {|hash| hash.keys.first }
+      expect(index_actions.sort).to eq([:create, :update, :delete].sort)
+    end
+  end
+
+  # it "execute uses what the dsl methods built up in memory and translates it dynmaodb params that then get used to execute and run the command" do
+  #   dsl.partition_key "id:string" # required
+  #   dsl.sort_key  "created_at:string" # optional
+  #   dsl.provisioned_throughput(25)
+  #   # dsl.execute # TODO: dsl.execute in here
+  # end
+end
+

data/vendor/dynomite/spec/lib/dynomite/migration/generator_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Dynomite::Migration::Generator do
+  before(:each) do
+    FileUtils.rm_rf("#{Dynomite.app_root}dynamodb/migrate")
+  end
+
+  let(:generator) do
+    Dynomite::Migration::Generator.new("comments",
+      partition_key: "post_id:string",
+      sort_key: "created_at:string",
+      quiet: true
+    )
+  end
+
+  it "generates migration file in dynamodb/migrate" do
+    generator.generate
+
+    migration_path = Dir.glob("#{Dynomite.app_root}dynamodb/migrate/*").first
+    migration_exist = File.exist?(migration_path)
+    expect(migration_exist).to be true
+  end
+end

data/vendor/dynomite/spec/lib/dynomite/migration_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+class CreateCommentsMigration < Dynomite::Migration
+  def up
+    create_table :comments do |t|
+      t.partition_key "post_id:string" # required
+      t.sort_key  "created_at:string" # optional
+      t.provisioned_throughput(5) # sets both read and write, defaults to 5 when not set
+    end
+  end
+end
+
+class UpdateCommentsMigration < Dynomite::Migration
+  def up
+    update_table :comments do |t|
+      # NOTE: You cannot update provisioned_throughput at the same time as creating
+      # an GSI
+      # t.provisioned_throughput(7) # sets both read and write, defaults to 5 when not set
+      t.gsi(:create) do |i|
+        i.partition_key "post_id:string"
+        i.sort_key "updated_at:string" # optional
+        i.provisioned_throughput(8)
+      end
+      # t.gsi(:update, "update-me-index") do |i|
+      #   i.provisioned_throughput(9)
+      # end
+      # t.gsi(:delete, "delete-me-index")
+    end
+  end
+end
+
+describe Dynomite::Migration do
+  context "mocked db" do
+    before(:each) { Dynomite::Migration::Dsl.db = db }
+    let(:db) { double(:db) }
+    let(:null) { double(:null).as_null_object }
+
+    it "executes the migration" do
+      allow(db).to receive(:create_table).and_return(null)
+
+      CreateCommentsMigration.new.up
+
+      expect(db).to have_received(:create_table)
+    end
+  end
+
+  # To test dynamodb endpoint configured in config/dynamodb.yml uncomment the code
+  # you want to test and run:
+  #
+  #   LIVE=1 rspec spec/lib/dynomite/migration_spec.rb -e 'live db'
+  #
+  context "live db" do
+    before(:each) { Dynomite::Item.db = nil } # setting to nil will clear out mock and force it to load AWS
+    it "executes the migration" do
+      CreateCommentsMigration.new.up # uncomment to test
+      # UpdateCommentsMigration.new.up # uncomment to test
+    end
+  end if ENV['LIVE']
+end
+