ldclient-rb 5.4.3 → 5.5.0

data/lib/ldclient-rb/memoized_value.rb

@@ -2,6 +2,8 @@
 module LaunchDarkly
   # Simple implementation of a thread-safe memoized value whose generator function will never be
   # run more than once, and whose value can be overridden by explicit assignment.
+  # Note that we no longer use this class and it will be removed in a future version.
+  # @private
   class MemoizedValue
     def initialize(&generator)
       @generator = generator

data/lib/ldclient-rb/newrelic.rb

@@ -1,4 +1,5 @@
 module LaunchDarkly
+  # @private
   class LDNewRelic
     begin
       require "newrelic_rpm"

data/lib/ldclient-rb/non_blocking_thread_pool.rb

@@ -3,10 +3,10 @@ require "concurrent/atomics"
 require "concurrent/executors"
 require "thread"
 
-# Simple wrapper for a FixedThreadPool that rejects new jobs if all the threads are busy, rather
-# than blocking. Also provides a way to wait for all jobs to finish without shutting down.
-
 module LaunchDarkly
+  # Simple wrapper for a FixedThreadPool that rejects new jobs if all the threads are busy, rather
+  # than blocking. Also provides a way to wait for all jobs to finish without shutting down.
+  # @private
   class NonBlockingThreadPool
     def initialize(capacity)
       @capacity = capacity

data/lib/ldclient-rb/polling.rb

@@ -2,6 +2,7 @@ require "concurrent/atomics"
 require "thread"
 
 module LaunchDarkly
+  # @private
   class PollingProcessor
     def initialize(config, requestor)
       @config = config

data/lib/ldclient-rb/redis_store.rb

@@ -1,5 +1,5 @@
-require "concurrent/atomics"
-require "json"
+require "ldclient-rb/interfaces"
+require "ldclient-rb/impl/integrations/redis_impl"
 
 module LaunchDarkly
   #
@@ -12,14 +12,16 @@ module LaunchDarkly
   # installed.  Then, create an instance and store it in the `feature_store` property
   # of your client configuration.
   #
+  # @deprecated Use the factory method in {LaunchDarkly::Integrations::Redis} instead. This specific
+  #   implementation class may be changed or removed in the future.
+  #
   class RedisFeatureStore
-    begin
-      require "redis"
-      require "connection_pool"
-      REDIS_ENABLED = true
-    rescue ScriptError, StandardError
-      REDIS_ENABLED = false
-    end
+    include LaunchDarkly::Interfaces::FeatureStore
+
+    # Note that this class is now just a facade around CachingStoreWrapper, which is in turn delegating
+    # to RedisFeatureStoreCore where the actual database logic is. This class was retained for historical
+    # reasons, so that existing code can still call RedisFeatureStore.new. In the future, we will migrate
+    # away from exposing these concrete classes and use factory methods instead.
 
     #
     # Constructor for a RedisFeatureStore instance.
@@ -30,45 +32,13 @@ module LaunchDarkly
     # @option opts [String] :prefix  namespace prefix to add to all hash keys used by LaunchDarkly
     # @option opts [Logger] :logger  a `Logger` instance; defaults to `Config.default_logger`
     # @option opts [Integer] :max_connections  size of the Redis connection pool
-    # @option opts [Integer] :expiration  expiration time for the in-memory cache, in seconds; 0 for no local caching
+    # @option opts [Integer] :expiration_seconds  expiration time for the in-memory cache, in seconds; 0 for no local caching
     # @option opts [Integer] :capacity  maximum number of feature flags (or related objects) to cache locally
-    # @option opts [Object] :pool  custom connection pool, used for testing only
+    # @option opts [Object] :pool  custom connection pool, if desired
     #
     def initialize(opts = {})
-      if !REDIS_ENABLED
-        raise RuntimeError.new("can't use RedisFeatureStore because one of these gems is missing: redis, connection_pool")
-      end
-      @redis_opts = opts[:redis_opts] || Hash.new
-      if opts[:redis_url]
-        @redis_opts[:url] = opts[:redis_url]
-      end
-      if !@redis_opts.include?(:url)
-        @redis_opts[:url] = RedisFeatureStore.default_redis_url
-      end
-      max_connections = opts[:max_connections] || 16
-      @pool = opts[:pool] || ConnectionPool.new(size: max_connections) do
-        Redis.new(@redis_opts)
-      end
-      @prefix = opts[:prefix] || RedisFeatureStore.default_prefix
-      @logger = opts[:logger] || Config.default_logger
-
-      expiration_seconds = opts[:expiration] || 15
-      capacity = opts[:capacity] || 1000
-      if expiration_seconds > 0
-        @cache = ExpiringCache.new(capacity, expiration_seconds)
-      else
-        @cache = nil
-      end
-
-      @stopped = Concurrent::AtomicBoolean.new(false)
-      @inited = MemoizedValue.new {
-        query_inited
-      }
-
-      with_connection do |redis|
-        @logger.info("RedisFeatureStore: using Redis instance at #{redis.connection[:host]}:#{redis.connection[:port]} \
-and prefix: #{@prefix}")
-      end
+      core = LaunchDarkly::Impl::Integrations::Redis::RedisFeatureStoreCore.new(opts)
+      @wrapper = LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
     end
 
     #
@@ -76,178 +46,42 @@ and prefix: #{@prefix}")
     # running at `localhost` with its default port.
     #
     def self.default_redis_url
-      'redis://localhost:6379/0'
+      LaunchDarkly::Integrations::Redis::default_redis_url
     end
 
     #
     # Default value for the `prefix` constructor parameter.
     #
     def self.default_prefix
-      'launchdarkly'
+      LaunchDarkly::Integrations::Redis::default_prefix
     end
 
     def get(kind, key)
-      f = @cache.nil? ? nil : @cache[cache_key(kind, key)]
-      if f.nil?
-        @logger.debug { "RedisFeatureStore: no cache hit for #{key} in '#{kind[:namespace]}', requesting from Redis" }
-        f = with_connection do |redis|
-          begin
-            get_redis(kind, redis, key.to_sym)
-          rescue => e
-            @logger.error { "RedisFeatureStore: could not retrieve #{key} from Redis in '#{kind[:namespace]}', with error: #{e}" }
-            nil
-          end
-        end
-      end
-      if f.nil?
-        @logger.debug { "RedisFeatureStore: #{key} not found in '#{kind[:namespace]}'" }
-        nil
-      elsif f[:deleted]
-        @logger.debug { "RedisFeatureStore: #{key} was deleted in '#{kind[:namespace]}', returning nil" }
-        nil
-      else
-        f
-      end
+      @wrapper.get(kind, key)
     end
 
     def all(kind)
-      fs = {}
-      with_connection do |redis|
-        begin
-          hashfs = redis.hgetall(items_key(kind))
-        rescue => e
-          @logger.error { "RedisFeatureStore: could not retrieve all '#{kind[:namespace]}' items from Redis with error: #{e}; returning none" }
-          hashfs = {}
-        end
-        hashfs.each do |k, jsonItem|
-          f = JSON.parse(jsonItem, symbolize_names: true)
-          if !f[:deleted]
-            fs[k.to_sym] = f
-          end
-        end
-      end
-      fs
+      @wrapper.all(kind)
     end
 
     def delete(kind, key, version)
-      update_with_versioning(kind, { key: key, version: version, deleted: true })
+      @wrapper.delete(kind, key, version)
     end
 
     def init(all_data)
-      @cache.clear if !@cache.nil?
-      count = 0
-      with_connection do |redis|
-        all_data.each do |kind, items|
-          begin
-            redis.multi do |multi|
-              multi.del(items_key(kind))
-              count = count + items.count
-              items.each { |key, item|
-                redis.hset(items_key(kind), key, item.to_json)
-              }
-            end
-            items.each { |key, item|
-              put_cache(kind, key.to_sym, item)
-            }
-          rescue => e
-            @logger.error { "RedisFeatureStore: could not initialize '#{kind[:namespace]}' in Redis, error: #{e}" }
-          end    
-        end
-      end
-      @inited.set(true)
-      @logger.info { "RedisFeatureStore: initialized with #{count} items" }
+      @wrapper.init(all_data)
     end
 
     def upsert(kind, item)
-      update_with_versioning(kind, item)
+      @wrapper.upsert(kind, item)
     end
 
     def initialized?
-      @inited.get
+      @wrapper.initialized?
     end
 
     def stop
-      if @stopped.make_true
-        @pool.shutdown { |redis| redis.close }
-        @cache.clear if !@cache.nil?
-      end
-    end
-
-    private
-
-    # exposed for testing
-    def before_update_transaction(base_key, key)
-    end
-
-    def items_key(kind)
-      @prefix + ":" + kind[:namespace]
-    end
-
-    def cache_key(kind, key)
-      kind[:namespace] + ":" + key.to_s
-    end
-
-    def with_connection
-      @pool.with { |redis| yield(redis) }
-    end
-
-    def get_redis(kind, redis, key)
-      begin
-        json_item = redis.hget(items_key(kind), key)
-        if json_item
-          item = JSON.parse(json_item, symbolize_names: true)
-          put_cache(kind, key, item)
-          item
-        else
-          nil
-        end
-      rescue => e
-        @logger.error { "RedisFeatureStore: could not retrieve #{key} from Redis, error: #{e}" }
-        nil
-      end
-    end
-
-    def put_cache(kind, key, value)
-      @cache[cache_key(kind, key)] = value if !@cache.nil?
-    end
-
-    def update_with_versioning(kind, new_item)
-      base_key = items_key(kind)
-      key = new_item[:key]
-      try_again = true
-      while try_again
-        try_again = false
-        with_connection do |redis|
-          redis.watch(base_key) do
-            old_item = get_redis(kind, redis, key)
-            before_update_transaction(base_key, key)
-            if old_item.nil? || old_item[:version] < new_item[:version]
-              begin
-                result = redis.multi do |multi|
-                  multi.hset(base_key, key, new_item.to_json)
-                end
-                if result.nil?
-                  @logger.debug { "RedisFeatureStore: concurrent modification detected, retrying" }
-                  try_again = true
-                else
-                  put_cache(kind, key.to_sym, new_item)
-                end
-              rescue => e
-                @logger.error { "RedisFeatureStore: could not store #{key} in Redis, error: #{e}" }
-              end
-            else
-              action = new_item[:deleted] ? "delete" : "update"
-              @logger.warn { "RedisFeatureStore: attempted to #{action} #{key} version: #{old_item[:version]} \
-      in '#{kind[:namespace]}' with a version that is the same or older: #{new_item[:version]}" }
-            end
-            redis.unwatch
-          end
-        end
-      end
-    end
-
-    def query_inited
-      with_connection { |redis| redis.exists(items_key(FEATURES)) }
+      @wrapper.stop
     end
   end
 end

data/lib/ldclient-rb/requestor.rb

@@ -3,7 +3,7 @@ require "net/http/persistent"
 require "faraday/http_cache"
 
 module LaunchDarkly
-
+  # @private
   class UnexpectedResponseError < StandardError
     def initialize(status)
       @status = status
@@ -14,12 +14,13 @@ module LaunchDarkly
     end
   end
 
+  # @private
   class Requestor
     def initialize(sdk_key, config)
       @sdk_key = sdk_key
       @config = config
       @client = Faraday.new do |builder|
-        builder.use :http_cache, store: @config.cache_store
+        builder.use :http_cache, store: @config.cache_store, serializer: Marshal
         
         builder.adapter :net_http_persistent
       end

data/lib/ldclient-rb/simple_lru_cache.rb

@@ -2,6 +2,7 @@
 module LaunchDarkly
   # A non-thread-safe implementation of a LRU cache set with only add and reset methods.
   # Based on https://github.com/SamSaffron/lru_redux/blob/master/lib/lru_redux/cache.rb
+  # @private
   class SimpleLRUCacheSet
     def initialize(capacity)
       @values = {}

data/lib/ldclient-rb/stream.rb

@@ -1,20 +1,28 @@
 require "concurrent/atomics"
 require "json"
-require "sse_client"
+require "ld-eventsource"
 
 module LaunchDarkly
+  # @private
   PUT = :put
+  # @private
   PATCH = :patch
+  # @private
   DELETE = :delete
+  # @private
   INDIRECT_PUT = :'indirect/put'
+  # @private
   INDIRECT_PATCH = :'indirect/patch'
+  # @private
   READ_TIMEOUT_SECONDS = 300  # 5 minutes; the stream should send a ping every 3 minutes
 
+  # @private
   KEY_PATHS = {
     FEATURES => "/flags/",
     SEGMENTS => "/segments/"
   }
 
+  # @private
   class StreamProcessor
     def initialize(sdk_key, config, requestor)
       @sdk_key = sdk_key
@@ -46,15 +54,18 @@ module LaunchDarkly
         read_timeout: READ_TIMEOUT_SECONDS,
         logger: @config.logger
       }
-      @es = SSE::SSEClient.new(@config.stream_uri + "/all", opts) do |conn|
-        conn.on_event { |event| process_message(event, event.type) }
+      @es = SSE::Client.new(@config.stream_uri + "/all", **opts) do |conn|
+        conn.on_event { |event| process_message(event) }
         conn.on_error { |err|
-          status = err[:status_code]
-          message = Util.http_error_message(status, "streaming connection", "will retry")
-          @config.logger.error { "[LDClient] #{message}" }
-          if !Util.http_error_recoverable?(status)
-            @ready.set  # if client was waiting on us, make it stop waiting - has no effect if already set
-            stop
+          case err
+          when SSE::Errors::HTTPStatusError
+            status = err.status
+            message = Util.http_error_message(status, "streaming connection", "will retry")
+            @config.logger.error { "[LDClient] #{message}" }
+            if !Util.http_error_recoverable?(status)
+              @ready.set  # if client was waiting on us, make it stop waiting - has no effect if already set
+              stop
+            end
           end
         }
       end
@@ -71,7 +82,8 @@ module LaunchDarkly
 
     private
 
-    def process_message(message, method)
+    def process_message(message)
+      method = message.type
       @config.logger.debug { "[LDClient] Stream received #{method} message: #{message.data}" }
       if method == PUT
         message = JSON.parse(message.data, symbolize_names: true)

data/lib/ldclient-rb/user_filter.rb

@@ -2,6 +2,7 @@ require "json"
 require "set"
 
 module LaunchDarkly
+  # @private
   class UserFilter
     def initialize(config)
       @all_attributes_private = config.all_attributes_private

data/lib/ldclient-rb/util.rb

@@ -1,5 +1,6 @@
 
 module LaunchDarkly
+  # @private
   module Util
     def self.log_exception(logger, message, exc)
       logger.error { "[LDClient] #{message}: #{exc.inspect}" }

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "5.4.3"
+  VERSION = "5.5.0"
 end

data/scripts/gendocs.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# Use this script to generate documentation locally in ./doc so it can be proofed before release.
+# After release, documentation will be visible at https://www.rubydoc.info/gems/ldclient-rb
+
+gem install --conservative yard
+gem install --conservative redcarpet  # provides Markdown formatting
+
+# yard doesn't seem to do recursive directories, even though Ruby's Dir.glob supposedly recurses for "**"
+PATHS="lib/*.rb lib/**/*.rb lib/**/**/*.rb lib/**/**/**/*.rb"
+
+yard doc --no-private --markup markdown --markup-provider redcarpet --embed-mixins $PATHS - README.md

data/spec/feature_store_spec_base.rb

@@ -1,112 +1,213 @@
 require "spec_helper"
 
-RSpec.shared_examples "feature_store" do |create_store_method|
+shared_examples "feature_store" do |create_store_method, clear_data_method|
 
-  let(:feature0) {
+  # Rather than testing with feature flag or segment data, we'll use this fake data kind
+  # to make it clear that feature stores need to be able to handle arbitrary data.
+  let(:things_kind) { { namespace: "things" } }
+
+  let(:key1) { "thing1" }
+  let(:thing1) {
     {
-      key: "test-feature-flag",
+      key: key1,
+      name: "Thing 1",
       version: 11,
-      on: true,
-      prerequisites: [],
-      salt: "718ea30a918a4eba8734b57ab1a93227",
-      sel: "fe1244e5378c4f99976c9634e33667c6",
-      targets: [
-        {
-           values: [ "alice" ],
-           variation: 0
-        },
-        {
-           values: [ "bob" ],
-           variation: 1
-        }
-      ],
-      rules: [],
-      fallthrough: { variation: 0 },
-      offVariation: 1,
-      variations: [ true, false ],
       deleted: false
     }
   }
-  let(:key0) { feature0[:key].to_sym }
+  let(:unused_key) { "no" }
+
+  let(:create_store) { create_store_method } # just to avoid a scope issue
+  let(:clear_data) { clear_data_method }
+
+  def with_store(opts = {})
+    s = create_store.call(opts)
+    begin
+      yield s
+    ensure
+      s.stop
+    end
+  end
+
+  def with_inited_store(things)
+    things_hash = {}
+    things.each { |thing| things_hash[thing[:key].to_sym] = thing }
 
-  let!(:store) do
-    s = create_store_method.call()
-    s.init(LaunchDarkly::FEATURES => { key0 => feature0 })
-    s
+    with_store do |s|
+      s.init({ things_kind => things_hash })
+      yield s
+    end
   end
 
   def new_version_plus(f, deltaVersion, attrs = {})
-    f1 = f.clone
-    f1[:version] = f[:version] + deltaVersion
-    f1.update(attrs)
-    f1
+    f.clone.merge({ version: f[:version] + deltaVersion }).merge(attrs)
   end
 
+  before(:each) do
+    clear_data.call if !clear_data.nil?
+  end
 
-  it "is initialized" do
-    expect(store.initialized?).to eq true
+  # This block of tests is only run if the clear_data method is defined, meaning that this is a persistent store
+  # that operates on a database that can be shared with other store instances (as opposed to the in-memory store,
+  # which has its own private storage).
+  if !clear_data_method.nil?
+    it "is not initialized by default" do
+      with_store do |store|
+        expect(store.initialized?).to eq false
+      end
+    end
+
+    it "can detect if another instance has initialized the store" do
+      with_store do |store1|
+        store1.init({})
+        with_store do |store2|
+          expect(store2.initialized?).to eq true
+        end
+      end
+    end
+
+    it "can read data written by another instance" do
+      with_store do |store1|
+        store1.init({ things_kind => { key1.to_sym => thing1 } })
+        with_store do |store2|
+          expect(store2.get(things_kind, key1)).to eq thing1
+        end
+      end
+    end
+
+    it "is independent from other stores with different prefixes" do
+      with_store({ prefix: "a" }) do |store_a|
+        store_a.init({ things_kind => { key1.to_sym => thing1 } })
+        with_store({ prefix: "b" }) do |store_b|
+          store_b.init({ things_kind => {} })
+        end
+        with_store({ prefix: "b" }) do |store_b1|  # this ensures we're not just reading cached data
+          expect(store_b1.get(things_kind, key1)).to be_nil
+          expect(store_a.get(things_kind, key1)).to eq thing1
+        end
+      end
+    end
   end
 
-  it "can get existing feature with symbol key" do
-    expect(store.get(LaunchDarkly::FEATURES, key0)).to eq feature0
+  it "is initialized after calling init" do
+    with_inited_store([]) do |store|
+      expect(store.initialized?).to eq true
+    end
   end
 
-  it "can get existing feature with string key" do
-    expect(store.get(LaunchDarkly::FEATURES, key0.to_s)).to eq feature0
+  it "can get existing item with symbol key" do
+    with_inited_store([ thing1 ]) do |store|
+      expect(store.get(things_kind, key1.to_sym)).to eq thing1
+    end
   end
 
-  it "gets nil for nonexisting feature" do
-    expect(store.get(LaunchDarkly::FEATURES, 'nope')).to be_nil
+  it "can get existing item with string key" do
+    with_inited_store([ thing1 ]) do |store|
+      expect(store.get(things_kind, key1.to_s)).to eq thing1
+    end
   end
 
-  it "can get all features" do
-    feature1 = feature0.clone
-    feature1[:key] = "test-feature-flag1"
-    feature1[:version] = 5
-    feature1[:on] = false
-    store.upsert(LaunchDarkly::FEATURES, feature1)
-    expect(store.all(LaunchDarkly::FEATURES)).to eq ({ key0 => feature0, :"test-feature-flag1" => feature1 })
+  it "gets nil for nonexisting item" do
+    with_inited_store([ thing1 ]) do |store|
+      expect(store.get(things_kind, unused_key)).to be_nil
+    end
   end
 
-  it "can add new feature" do
-    feature1 = feature0.clone
-    feature1[:key] = "test-feature-flag1"
-    feature1[:version] = 5
-    feature1[:on] = false
-    store.upsert(LaunchDarkly::FEATURES, feature1)
-    expect(store.get(LaunchDarkly::FEATURES, :"test-feature-flag1")).to eq feature1
+  it "returns nil for deleted item" do
+    deleted_thing = thing1.clone.merge({ deleted: true })
+    with_inited_store([ deleted_thing ]) do |store|
+      expect(store.get(things_kind, key1)).to be_nil
+    end
   end
 
-  it "can update feature with newer version" do
-    f1 = new_version_plus(feature0, 1, { on: !feature0[:on] })
-    store.upsert(LaunchDarkly::FEATURES, f1)
-    expect(store.get(LaunchDarkly::FEATURES, key0)).to eq f1
+  it "can get all items" do
+    key2 = "thing2"
+    thing2 = {
+      key: key2,
+      name: "Thing 2",
+      version: 22,
+      deleted: false
+    }
+    with_inited_store([ thing1, thing2 ]) do |store|
+      expect(store.all(things_kind)).to eq ({ key1.to_sym => thing1, key2.to_sym => thing2 })
+    end
+  end
+
+  it "filters out deleted items when getting all" do
+    key2 = "thing2"
+    thing2 = {
+      key: key2,
+      name: "Thing 2",
+      version: 22,
+      deleted: true
+    }
+    with_inited_store([ thing1, thing2 ]) do |store|
+      expect(store.all(things_kind)).to eq ({ key1.to_sym => thing1 })
+    end
   end
 
-  it "cannot update feature with same version" do
-    f1 = new_version_plus(feature0, 0, { on: !feature0[:on] })
-    store.upsert(LaunchDarkly::FEATURES, f1)
-    expect(store.get(LaunchDarkly::FEATURES, key0)).to eq feature0
+  it "can add new item" do
+    with_inited_store([]) do |store|
+      store.upsert(things_kind, thing1)
+      expect(store.get(things_kind, key1)).to eq thing1
+    end
+  end
+
+  it "can update item with newer version" do
+    with_inited_store([ thing1 ]) do |store|
+      thing1_mod = new_version_plus(thing1, 1, { name: thing1[:name] + ' updated' })
+      store.upsert(things_kind, thing1_mod)
+      expect(store.get(things_kind, key1)).to eq thing1_mod
+    end
+  end
+
+  it "cannot update item with same version" do
+    with_inited_store([ thing1 ]) do |store|
+      thing1_mod = thing1.clone.merge({ name: thing1[:name] + ' updated' })
+      store.upsert(things_kind, thing1_mod)
+      expect(store.get(things_kind, key1)).to eq thing1
+    end
   end
 
   it "cannot update feature with older version" do
-    f1 = new_version_plus(feature0, -1, { on: !feature0[:on] })
-    store.upsert(LaunchDarkly::FEATURES, f1)
-    expect(store.get(LaunchDarkly::FEATURES, key0)).to eq feature0
+    with_inited_store([ thing1 ]) do |store|
+      thing1_mod = new_version_plus(thing1, -1, { name: thing1[:name] + ' updated' })
+      store.upsert(things_kind, thing1_mod)
+      expect(store.get(things_kind, key1)).to eq thing1
+    end
   end
 
-  it "can delete feature with newer version" do
-    store.delete(LaunchDarkly::FEATURES, key0, feature0[:version] + 1)
-    expect(store.get(LaunchDarkly::FEATURES, key0)).to be_nil
+  it "can delete item with newer version" do
+    with_inited_store([ thing1 ]) do |store|
+      store.delete(things_kind, key1, thing1[:version] + 1)
+      expect(store.get(things_kind, key1)).to be_nil
+    end
   end
 
-  it "cannot delete feature with same version" do
-    store.delete(LaunchDarkly::FEATURES, key0, feature0[:version])
-    expect(store.get(LaunchDarkly::FEATURES, key0)).to eq feature0
+  it "cannot delete item with same version" do
+    with_inited_store([ thing1 ]) do |store|
+      store.delete(things_kind, key1, thing1[:version])
+      expect(store.get(things_kind, key1)).to eq thing1
+    end
   end
 
-  it "cannot delete feature with older version" do
-    store.delete(LaunchDarkly::FEATURES, key0, feature0[:version] - 1)
-    expect(store.get(LaunchDarkly::FEATURES, key0)).to eq feature0
+  it "cannot delete item with older version" do
+    with_inited_store([ thing1 ]) do |store|
+      store.delete(things_kind, key1, thing1[:version] - 1)
+      expect(store.get(things_kind, key1)).to eq thing1
+    end
+  end
+
+  it "stores Unicode data correctly" do
+    flag = {
+      key: "my-fancy-flag",
+      name: "Tęst Feåtūre Flæg😺",
+      version: 1,
+      deleted: false
+    }
+    with_inited_store([]) do |store|
+      store.upsert(LaunchDarkly::FEATURES, flag)
+      expect(store.get(LaunchDarkly::FEATURES, flag[:key])).to eq flag
+    end
   end
 end