oplogjam 0.1.0

data/spec/oplogjam/noop_spec.rb

@@ -0,0 +1,123 @@
+require 'bson'
+require 'oplogjam'
+
+module Oplogjam
+  RSpec.describe Noop do
+    describe '.from' do
+      it 'converts a BSON no-op into an Noop' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_419_535, 1),
+          h: -2_135_725_856_567_446_411,
+          v: 2,
+          op: 'n',
+          ns: '',
+          o: BSON::Document.new(msg: 'initiating set')
+        )
+
+        expect(described_class.from(bson)).to be_a(described_class)
+      end
+
+      it 'raises an error if the message is missing' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_419_535, 1),
+          h: -2_135_725_856_567_446_411,
+          v: 2,
+          op: 'n',
+          ns: '',
+          o: BSON::Document.new(foo: 'bar')
+        )
+
+        expect { described_class.from(bson) }.to raise_error(InvalidNoop)
+      end
+    end
+
+    describe '#message' do
+      it 'returns the message' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_419_535, 1),
+          h: -2_135_725_856_567_446_411,
+          v: 2,
+          op: 'n',
+          ns: '',
+          o: BSON::Document.new(msg: 'initiating set')
+        )
+        noop = described_class.from(bson)
+
+        expect(noop.message).to eq('initiating set')
+      end
+    end
+
+    describe '#id' do
+      it 'returns a unique identifier for the operation' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_419_535, 1),
+          h: -2_135_725_856_567_446_411,
+          v: 2,
+          op: 'n',
+          ns: '',
+          o: BSON::Document.new(msg: 'initiating set')
+        )
+        noop = described_class.from(bson)
+
+        expect(noop.id).to eq(-2_135_725_856_567_446_411)
+      end
+    end
+
+    describe '#timestamp' do
+      it 'returns the time of the operation as a Time' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_419_535, 1),
+          h: -2_135_725_856_567_446_411,
+          v: 2,
+          op: 'n',
+          ns: '',
+          o: BSON::Document.new(msg: 'initiating set')
+        )
+        noop = described_class.from(bson)
+
+        expect(noop.timestamp).to eq(Time.at(1_479_419_535, 1))
+      end
+    end
+
+    describe '#ts' do
+      it 'returns the raw underlying BSON timestamp' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_419_535, 1),
+          h: -2_135_725_856_567_446_411,
+          v: 2,
+          op: 'n',
+          ns: '',
+          o: BSON::Document.new(msg: 'initiating set')
+        )
+        noop = described_class.from(bson)
+
+        expect(noop.ts).to eq(BSON::Timestamp.new(1_479_419_535, 1))
+      end
+    end
+
+    describe '#==' do
+      it 'is equal to another noop with the same ID' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_419_535, 1),
+          h: -2_135_725_856_567_446_411,
+          v: 2,
+          op: 'n',
+          ns: '',
+          o: BSON::Document.new(msg: 'initiating set')
+        )
+        another_bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_419_535, 1),
+          h: -2_135_725_856_567_446_411,
+          v: 2,
+          op: 'n',
+          ns: '',
+          o: BSON::Document.new(msg: 'initiating set')
+        )
+        noop = described_class.from(bson)
+        another_noop = described_class.from(another_bson)
+
+        expect(noop).to eq(another_noop)
+      end
+    end
+  end
+end

data/spec/oplogjam/operation_spec.rb

@@ -0,0 +1,110 @@
+require 'bson'
+require 'oplogjam'
+
+module Oplogjam
+  RSpec.describe Operation do
+    describe '.from' do
+      it 'converts BSON no-ops into Noop' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_419_535, 1),
+          h: -2_135_725_856_567_446_411,
+          v: 2,
+          op: 'n',
+          ns: '',
+          o: BSON::Document.new(msg: 'initiating set')
+        )
+
+        expect(described_class.from(bson)).to be_a(Noop)
+      end
+
+      it 'converts BSON inserts into Inserts' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_496_414_570, 11),
+          t: 14,
+          h: -3_028_027_288_268_436_781,
+          v: 2,
+          op: 'i',
+          ns: 'foo.bar',
+          o: BSON::Document.new(_id: 1, baz: 'quux')
+        )
+
+        expect(described_class.from(bson)).to be_a(Insert)
+      end
+
+      it 'converts BSON updates into Updates' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_561_033, 1),
+          t: 2,
+          h: 3_511_341_713_062_188_019,
+          v: 2,
+          op: 'u',
+          ns: 'foo.bar',
+          o2: BSON::Document.new(_id: BSON::ObjectId('583033a3643431ab5be6ec35')),
+          o: BSON::Document.new('$set' => BSON::Document.new('bar' => 'baz'))
+        )
+
+        expect(described_class.from(bson)).to be_a(Update)
+      end
+
+      it 'converts BSON deletes into Deletes' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_421_186, 1),
+          t: 1,
+          h: -5_457_382_347_563_537_847,
+          v: 2,
+          op: 'd',
+          ns: 'foo.bar',
+          o: BSON::Document.new(_id: BSON::ObjectId('582e287cfedf6fb051b2efdf'))
+        )
+
+        expect(described_class.from(bson)).to be_a(Delete)
+      end
+
+      it 'converts BSON commands into Commands' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_420_028, 1),
+          t: 1,
+          h: -1_789_557_309_812_000_233,
+          v: 2,
+          op: 'c',
+          ns: 'foo.$cmd',
+          o: BSON::Document.new(create: 'bar')
+        )
+
+        expect(described_class.from(bson)).to be_a(Command)
+      end
+
+      it 'converts BSON applyOps into ApplyOps' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_420_028, 1),
+          t: 1,
+          h: -1_789_557_309_812_000_233,
+          v: 2,
+          op: 'c',
+          ns: 'foo.$cmd',
+          o: BSON::Document.new(
+            applyOps: [
+              BSON::Document.new(
+                ts: BSON::Timestamp.new(1_496_414_570, 11),
+                t: 14,
+                h: -3_028_027_288_268_436_781,
+                v: 2,
+                op: 'i',
+                ns: 'foo.bar',
+                o: BSON::Document.new(_id: 1, baz: 'quux')
+              )
+            ]
+          )
+        )
+
+        expect(described_class.from(bson)).to be_a(Oplogjam::ApplyOps)
+      end
+
+      it 'raises an error if given an unknown operation' do
+        bson = BSON::Document.new(not: 'an operation')
+
+        expect { described_class.from(bson) }.to raise_error(InvalidOperation)
+      end
+    end
+  end
+end

data/spec/oplogjam/operators/set_spec.rb

@@ -0,0 +1,53 @@
+require 'oplogjam'
+
+module Oplogjam
+  module Operators
+    RSpec.describe Set do
+      describe '.update' do
+        it 'converts a simple $set into SQL' do
+          sql = described_class.from('a' => 1).update(Sequel.pg_jsonb_op(:document))
+
+          expect(sql).to eq(Sequel.pg_jsonb_op(:document).set(%w[a], '1'))
+        end
+
+        it 'converts several simple $sets into SQL' do
+          sql = described_class.from('a' => 1, 'b' => 2).update(Sequel.pg_jsonb_op(:document))
+
+          expect(sql).to eq(Sequel.pg_jsonb_op(:document).set(%w[a], '1').set(%w[b], '2'))
+        end
+
+        it 'converts a single nested $set into SQL' do
+          sql = described_class.from('a.b' => 1).update(Sequel.pg_jsonb_op(:document))
+
+          expect(sql).to eq(
+            Sequel
+              .pg_jsonb_op(:document)
+              .set(%w[a], Sequel.function(:coalesce, Sequel.pg_jsonb_op(:document)[%w[a]], Sequel.pg_jsonb({})))
+              .set(%w[a b], '1')
+          )
+        end
+
+        it 'converts a complex $set tree into a SQL expression' do
+          sql = described_class.from('a.b.c' => 1, 'a.b.d' => 2, 'a.e' => 3).update(Sequel.pg_jsonb_op(:document))
+
+          document = Sequel.pg_jsonb_op(:document)
+          a_root = document.set(
+            %w[a],
+            Sequel.function(:coalesce, document[%w[a]], Sequel.pg_jsonb({}))
+          )
+
+          expect(sql).to eq(
+            a_root
+              .set(
+                %w[a b],
+                Sequel.function(:coalesce, a_root[%w[a b]], Sequel.pg_jsonb({}))
+              )
+              .set(%w[a b c], '1')
+              .set(%w[a b d], '2')
+              .set(%w[a e], '3')
+          )
+        end
+      end
+    end
+  end
+end

data/spec/oplogjam/sanitizer_spec.rb

@@ -0,0 +1,35 @@
+require 'oplogjam'
+
+module Oplogjam
+  RSpec.describe Sanitizer do
+    describe '.sanitize' do
+      it 'strips null bytes from strings' do
+        expect(described_class.sanitize("Foo\x00bar\x00")).to eq('Foobar')
+      end
+
+      it 'does not strip escaped null bytes from strings' do
+        expect(described_class.sanitize('Foo\u0000bar')).to eq('Foo\u0000bar')
+      end
+
+      it 'strips null bytes from array elements' do
+        expect(described_class.sanitize(["Foo\x00", "\x00Bar"])).to eq(['Foo', 'Bar'])
+      end
+
+      it 'strips null bytes from JSONB array elements' do
+        expect(described_class.sanitize(Sequel::Postgres::JSONBArray.new(["Foo\x00", "\x00Bar"]))).to eq(['Foo', 'Bar'])
+      end
+
+      it 'strips null bytes from hash values' do
+        expect(described_class.sanitize('name' => "Foo\x00")).to eq('name' => 'Foo')
+      end
+
+      it 'strips null bytes from hash keys' do
+        expect(described_class.sanitize("\x00name" => 'Foo')).to eq('name' => 'Foo')
+      end
+
+      it 'strips null bytes from JSONB hash elements' do
+        expect(described_class.sanitize(Sequel::Postgres::JSONBHash.new('name' => "Foo\x00"))).to eq('name' => 'Foo')
+      end
+    end
+  end
+end

data/spec/oplogjam/update_spec.rb

@@ -0,0 +1,406 @@
+require 'bson'
+require 'oplogjam'
+
+module Oplogjam
+  RSpec.describe Update do
+    let(:postgres) { Sequel.connect('postgres:///oplogjam_test') }
+    let(:schema) { Schema.new(postgres) }
+    let(:table) { postgres.from(:bar) }
+
+    before(:example, :database) do
+      postgres.extension :pg_json
+      schema.create_table(:bar)
+      schema.add_indexes(:bar)
+    end
+
+    after(:example, :database) do
+      table.truncate
+    end
+
+    describe '.from' do
+      it 'converts a BSON update into an Update' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_561_033, 1),
+          t: 2,
+          h: 3_511_341_713_062_188_019,
+          v: 2,
+          op: 'u',
+          ns: 'foo.bar',
+          o2: BSON::Document.new(_id: BSON::ObjectId('583033a3643431ab5be6ec35')),
+          o: BSON::Document.new('$set' => BSON::Document.new('bar' => 'baz'))
+        )
+
+        expect(described_class.from(bson)).to be_a(described_class)
+      end
+
+      it 'raises an error if the query is missing' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_561_033, 1),
+          t: 2,
+          h: 3_511_341_713_062_188_019,
+          v: 2,
+          op: 'u',
+          ns: 'foo.bar',
+          o: BSON::Document.new('$set' => BSON::Document.new('bar' => 'baz'))
+        )
+
+        expect { described_class.from(bson) }.to raise_error(InvalidUpdate)
+      end
+    end
+
+    describe '#timestamp' do
+      it 'returns the timestamp of the operation as a Time' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_561_033, 1),
+          t: 2,
+          h: 3_511_341_713_062_188_019,
+          v: 2,
+          op: 'u',
+          ns: 'foo.bar',
+          o2: BSON::Document.new(_id: BSON::ObjectId('583033a3643431ab5be6ec35')),
+          o: BSON::Document.new('$set' => BSON::Document.new('bar' => 'baz'))
+        )
+        update = described_class.from(bson)
+
+        expect(update.timestamp).to eq(Time.at(1_479_561_033, 1))
+      end
+    end
+
+    describe '#namespace' do
+      it 'returns the namespace' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_561_033, 1),
+          t: 2,
+          h: 3_511_341_713_062_188_019,
+          v: 2,
+          op: 'u',
+          ns: 'foo.bar',
+          o2: BSON::Document.new(_id: BSON::ObjectId('583033a3643431ab5be6ec35')),
+          o: BSON::Document.new('$set' => BSON::Document.new('bar' => 'baz'))
+        )
+        update = described_class.from(bson)
+
+        expect(update.namespace).to eq('foo.bar')
+      end
+    end
+
+    describe '#query' do
+      it 'returns the query' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_561_033, 1),
+          t: 2,
+          h: 3_511_341_713_062_188_019,
+          v: 2,
+          op: 'u',
+          ns: 'foo.bar',
+          o2: BSON::Document.new(_id: BSON::ObjectId('583033a3643431ab5be6ec35')),
+          o: BSON::Document.new('$set' => BSON::Document.new('bar' => 'baz'))
+        )
+        update = described_class.from(bson)
+
+        expect(update.query).to eq(BSON::Document.new(_id: BSON::ObjectId('583033a3643431ab5be6ec35')))
+      end
+    end
+
+    describe '#update' do
+      it 'returns the update' do
+        bson = BSON::Document.new(
+          ts: BSON::Timestamp.new(1_479_561_033, 1),
+          t: 2,
+          h: 3_511_341_713_062_188_019,
+          v: 2,
+          op: 'u',
+          ns: 'foo.bar',
+          o2: BSON::Document.new(_id: BSON::ObjectId('583033a3643431ab5be6ec35')),
+          o: BSON::Document.new('$set' => BSON::Document.new('bar' => 'baz'))
+        )
+        update = described_class.from(bson)
+
+        expect(update.update).to eq(BSON::Document.new('$set' => BSON::Document.new('bar' => 'baz')))
+      end
+    end
+
+    describe '#apply', :database do
+      it 'ignores updates to unmapped tables' do
+        table.insert(id: '1', document: '{"_id":1,"a":1}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, 'a' => 2)
+        update.apply('foo.baz' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => 1))
+      end
+
+      it 'strips null bytes from updates' do
+        table.insert(id: '1', document: '{"_id":1}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, 'foo' => "bar\x00")
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'foo' => 'bar'))
+      end
+
+      it 'updates updated_at' do
+        Timecop.freeze(Time.new(2001, 1, 1, 0, 0, 0)) do
+          table.insert(id: '1', document: '{"_id":1}', created_at: Time.now.utc, updated_at: Time.now.utc)
+          update = build_update(1, 'a' => 1)
+          update.apply('foo.bar' => table)
+
+          expect(table.first).to include(updated_at: Time.new(2001, 1, 1, 0, 0, 0))
+        end
+      end
+
+      it 'applies {"a"=>1, "b"=>2} to {}' do
+        table.insert(id: '1', document: '{"_id":1}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, 'a' => 1, 'b' => 2)
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => 1, 'b' => 2))
+      end
+
+      it 'applies {"$set"=>{"a"=>1}} to {}' do
+        table.insert(id: '1', document: '{"_id":1}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => 1))
+      end
+
+      it 'applies {"$set"=>{"a"=>1}} to {"a"=>0}' do
+        table.insert(id: '1', document: '{"_id":1,"a":0}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => 1))
+      end
+
+      it 'applies {"$set"=>{"a"=>1, "b"=>2}} to {}' do
+        table.insert(id: '1', document: '{"_id":1}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a' => 1, 'b' => 2 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => 1, 'b' => 2))
+      end
+
+      it 'applies {"$set"=>{"a"=>1, "b"=>2}} to {"a"=>0, "b"=>0}' do
+        table.insert(id: '1', document: '{"_id":1,"a":0,"b":0}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a' => 1, 'b' => 2 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => 1, 'b' => 2))
+      end
+
+      it 'applies {"$unset"=>{"a"=>""}} to {"a"=>0, "b"=>0}' do
+        table.insert(id: '1', document: '{"_id":1,"a":0,"b":0}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$unset' => { 'a' => '' })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'b' => 0))
+      end
+
+      it 'applies {"$unset"=>{"a"=>"", "b"=>""}} to {"a"=>0, "b"=>0}' do
+        table.insert(id: '1', document: '{"_id":1,"a":0,"b":0}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$unset' => { 'a' => '', 'b' => '' })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1))
+      end
+
+      it 'applies {"$unset"=>{"c"=>""}} to {"a"=>0, "b"=>0}' do
+        table.insert(id: '1', document: '{"_id":1,"a":0,"b":0}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$unset' => { 'c' => '' })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => 0, 'b' => 0))
+      end
+
+      it 'applies {"$set"=>{"b"=>1}, "$unset"=>{"a"=>""}} to {"a"=>0}' do
+        table.insert(id: '1', document: '{"_id":1,"a":0}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'b' => 1 }, '$unset' => { 'a' => '' })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'b' => 1))
+      end
+
+      it 'applies {"$set"=>{"a.0"=>1}} to {}' do
+        table.insert(id: '1', document: '{"_id":1}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a.0' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => { '0' => 1 }))
+      end
+
+      it 'applies {"$set"=>{"a.0"=>1}} to {"a"=>[]}' do
+        table.insert(id: '1', document: '{"_id":1,"a":[]}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a.0' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => [1]))
+      end
+
+      it 'applies {"$set"=>{"a.0"=>1}} to {"a"=>{}}' do
+        table.insert(id: '1', document: '{"_id":1,"a":{}}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a.0' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => { '0' => 1 }))
+      end
+
+      it 'applies {"$set"=>{"a.1"=>1}} to {"a"=>[]}' do
+        table.insert(id: '1', document: '{"_id":1,"a":[]}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a.1' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => [nil, 1]))
+      end
+
+      it 'applies {"$unset"=>{"a.0"=>""}} to {}' do
+        table.insert(id: '1', document: '{"_id":1}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$unset' => { 'a.0' => '' })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1))
+      end
+
+      it 'applies {"$unset"=>{"a.0"=>""}} to {"a"=>[]}' do
+        table.insert(id: '1', document: '{"_id":1,"a":[]}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$unset' => { 'a.0' => '' })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => []))
+      end
+
+      it 'applies {"$unset"=>{"a.0"=>""}} to {"a"=>[1]}' do
+        table.insert(id: '1', document: '{"_id":1,"a":[1]}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$unset' => { 'a.0' => '' })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => [nil]))
+      end
+
+      it 'applies {"$unset"=>{"a.0"=>""}} to {"a"=>[1, 2]}' do
+        table.insert(id: '1', document: '{"_id":1,"a":[1,2]}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$unset' => { 'a.0' => '' })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => [nil, 2]))
+      end
+
+      it 'applies {"$unset"=>{"a.1"=>""}} to {"a"=>[1, 2]}' do
+        table.insert(id: '1', document: '{"_id":1,"a":[1,2]}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$unset' => { 'a.1' => '' })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => [1, nil]))
+      end
+
+      it 'applies {"$unset"=>{"a.2"=>""}} to {"a"=>[1, 2]}' do
+        table.insert(id: '1', document: '{"_id":1,"a":[1,2]}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$unset' => { 'a.2' => '' })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => [1, 2]))
+      end
+
+      it 'applies {"$unset"=>{"a.0"=>""}} to {"a"=>{}}' do
+        table.insert(id: '1', document: '{"_id":1,"a":{}}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$unset' => { 'a.0' => '' })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => {}))
+      end
+
+      it 'applies {"$unset"=>{"a.1"=>""}} to {"a"=>[]}' do
+        table.insert(id: '1', document: '{"_id":1,"a":[]}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$unset' => { 'a.1' => '' })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => []))
+      end
+
+      it 'applies {"$set"=>{"a.b"=>1}} to {}' do
+        table.insert(id: '1', document: '{"_id":1}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a.b' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => { 'b' => 1 }))
+      end
+
+      it 'applies {"$set"=>{"a.b.c"=>1}} to {}' do
+        table.insert(id: '1', document: '{"_id":1}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a.b.c' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => { 'b' => { 'c' => 1 } }))
+      end
+
+      it 'applies {"$set"=>{"a.b.c"=>1, "a.d"=>2}} to {}' do
+        table.insert(id: '1', document: '{"_id":1}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a.b.c' => 1, 'a.d' => 2 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => { 'b' => { 'c' => 1 }, 'd' => 2 }))
+      end
+
+      it 'applies {"$set"=>{"a.b"=>1}} to {"a"=>{}}' do
+        table.insert(id: '1', document: '{"_id":1,"a":{}}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a.b' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => { 'b' => 1 }))
+      end
+
+      it 'applies {"$set"=>{"a.b"=>1}} to {"a"=>{"b"=>0}}' do
+        table.insert(id: '1', document: '{"_id":1,"a":{"b":0}}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a.b' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => { 'b' => 1 }))
+      end
+
+      it 'applies {"$set"=>{"a.1.b"=>1}} to {}' do
+        table.insert(id: '1', document: '{"_id":1}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a.1.b' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => { '1' => { 'b' => 1 } }))
+      end
+
+      it 'applies {"$set"=>{"a.1.b"=>1}} to {"a"=>[]}' do
+        table.insert(id: '1', document: '{"_id":1,"a":[]}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a.1.b' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => [nil, { 'b' => 1 }]))
+      end
+
+      it 'applies {"$set"=>{"a.1.b.1"=>1}} to {}' do
+        table.insert(id: '1', document: '{"_id":1}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a.1.b.1' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => { '1' => { 'b' => { '1' => 1 } } }))
+      end
+
+      it 'applies {"$set"=>{"a.1.b.1"=>1}} to {"a"=>[]}' do
+        table.insert(id: '1', document: '{"_id":1,"a":[]}', created_at: Time.now.utc, updated_at: Time.now.utc)
+        update = build_update(1, '$set' => { 'a.1.b.1' => 1 })
+        update.apply('foo.bar' => table)
+
+        expect(table.first).to include(document: Sequel.pg_jsonb('_id' => 1, 'a' => [nil, { 'b' => { '1' => 1 } }]))
+      end
+    end
+
+    def build_update(id = '1', attributes = { '$set' => BSON::Document.new('bar' => 'baz') })
+      bson = BSON::Document.new(
+        ts: BSON::Timestamp.new(1_479_561_033, 1),
+        t: 2,
+        h: 3_511_341_713_062_188_019,
+        v: 2,
+        op: 'u',
+        ns: 'foo.bar',
+        o2: BSON::Document.new(_id: id),
+        o: BSON::Document.new(attributes)
+      )
+
+      described_class.from(bson)
+    end
+  end
+end