prefab-cloud-ruby 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bedbb49cbc2b12ed093d5740ddbcfa26398faefe
-  data.tar.gz: fcd3d2e87c37927243f2ad475e0564d3a99eecc0
+  metadata.gz: e4ae024730e476fe81b2d5e1130bb13e0dfee4f6
+  data.tar.gz: aa819d0f9c64ffcd8826751d176133fce7a1a57e
 SHA512:
-  metadata.gz: b4cf667a4d6495d12a19af12018f50d423b8dd5b32dcbe0b95fcbfbded7ddfa127ae1d804d3fc44db7df5bb4e2a6c3d8c4d25255b9e274b7e4a469b629b5ed08
-  data.tar.gz: ad6a8ffb65d448f35a7276910cc36825491f4ee467bd7fd02e4486f1ee68fe1d27d28848a2c9c8be3189aa8339662a83b64960a2b7c5a255574634c656cbca00
+  metadata.gz: c10adec4b6866caee1045830c4ad45f2f36b20011e3ed8c3d4670331e62f0b65b3b57bd91c0c19dbe9ce4e164787cc5717d622fbe8cbe6cbbca21e03e54bfcf0
+  data.tar.gz: e75c1d4c816f403e974e7b1f105d233fa1578e667d4cfaa804daea81e9ba633478cdba059dab2705ddc45721b3ee734edf1dd2d52dbb1990cc16bd4f28ef203b

data/Gemfile

@@ -1,10 +1,10 @@
 source "https://rubygems.org"
 
-gem 'grpc', '~> 1.7.3'
+gem 'grpc', '~> 1.8.3'
 gem 'concurrent-ruby', '~> 1.0', '>= 1.0.5'
 
 group :development do
-  gem 'grpc-tools', '~> 1.8'
+  gem 'grpc-tools', '~> 1.8.3'
   gem "shoulda", ">= 0"
   gem "rdoc", "~> 3.12"
   gem "bundler", "~> 1.0"

data/Gemfile.lock

@@ -22,7 +22,7 @@ GEM
       faraday (~> 0.8)
       hashie (~> 3.5, >= 3.5.2)
       oauth2 (~> 1.0)
-    google-protobuf (3.5.0)
+    google-protobuf (3.5.1)
     googleapis-common-protos-types (1.0.1)
       google-protobuf (~> 3.0)
     googleauth (0.6.2)
@@ -33,11 +33,11 @@ GEM
       multi_json (~> 1.11)
       os (~> 0.9)
       signet (~> 0.7)
-    grpc (1.7.3)
+    grpc (1.8.3)
       google-protobuf (~> 3.1)
       googleapis-common-protos-types (~> 1.0.0)
       googleauth (>= 0.5.1, < 0.7)
-    grpc-tools (1.8.0)
+    grpc-tools (1.8.3)
     hashie (3.5.6)
     highline (1.7.10)
     i18n (0.9.1)
@@ -105,8 +105,8 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.0)
   concurrent-ruby (~> 1.0, >= 1.0.5)
-  grpc (~> 1.7.3)
-  grpc-tools (~> 1.8)
+  grpc (~> 1.8.3)
+  grpc-tools (~> 1.8.3)
   juwelier (~> 2.1.0)
   rdoc (~> 3.12)
   shoulda

data/VERSION

@@ -1 +1 @@
-0.0.9
+0.0.10

data/lib/prefab/client.rb

@@ -1,8 +1,8 @@
 module Prefab
   class Client
-    attr_reader :account_id, :shared_cache, :stats, :namespace, :logger, :creds, :channel, :interceptor
+    attr_reader :account_id, :shared_cache, :stats, :namespace, :logger, :creds, :interceptor
 
-    def initialize(api_key:,
+    def initialize(api_key: ENV['PREFAB_API_KEY'],
                    logger: nil,
                    stats: nil, # receives increment("prefab.limitcheck", {:tags=>["policy_group:page_view", "pass:true"]})
                    shared_cache: nil, # Something that quacks like Rails.cache ideally memcached
@@ -12,6 +12,7 @@ module Prefab
       @logger = (logger || Logger.new($stdout)).tap do |log|
         log.progname = "Prefab" if log.respond_to? :progname=
       end
+      @local = local
       @stats = (stats || NoopStats.new)
       @shared_cache = (shared_cache || NoopCache.new)
       @account_id = api_key.split("|")[0].to_i
@@ -20,10 +21,17 @@ module Prefab
       @interceptor = AuthInterceptor.new(api_key)
 
       @creds = GRPC::Core::ChannelCredentials.new(ssl_certs)
-      @channel = GRPC::Core::Channel.new('api.prefab.cloud:8443', nil, @creds)
-      if local
-        @channel = GRPC::Core::Channel.new('localhost:8443', nil, :this_channel_is_insecure)
-      end
+    end
+
+    def channel
+      @_channel ||= @local ?
+                      GRPC::Core::Channel.new('localhost:8443', nil, :this_channel_is_insecure)
+                      :
+                      GRPC::Core::Channel.new('api.prefab.cloud:8443', nil, @creds)
+    end
+
+    def reset_channel!
+      @_channel = nil
     end
 
     def config_client(timeout: 5.0)

data/lib/prefab/config_client.rb

@@ -1,61 +1,161 @@
 module Prefab
   class ConfigClient
     RECONNECT_WAIT = 5
+    CHECKPOINT_FREQ_SEC = 10
+    SUSPENDERS_FREQ_SEC = 60
 
     def initialize(base_client, timeout)
       @base_client = base_client
       @timeout = timeout
-      @config_resolver = EzConfig::ConfigResolver.new(base_client)
-      boot_resolver
+      @config_loader = Prefab::ConfigLoader.new(base_client)
+      @config_resolver = Prefab::ConfigResolver.new(base_client, @config_loader)
+      start_at_id = load_checkpoint
+      start_api_connection_thread(start_at_id)
+      start_checkpointing_thread
+      start_suspenders_thread
     end
 
     def get(prop)
       @config_resolver.get(prop)
     end
 
-    def set(config_delta)
-      Retry.it method(:stub_with_timout), :upsert, config_delta, @timeout
-      @config_resolver.set(config_delta)
+    def set(key, config_value, namespace = nil)
+      raise "key must not contain ':' set namespaces separately" if key.include? ":"
+      raise "namespace must not contain ':'" if namespace&.include?(":")
+      config_delta = Prefab::ConfigClient.value_to_delta(key, config_value, namespace)
+      Retry.it method(:stub_with_timeout), :upsert, config_delta, @timeout, method(:reset)
+      @config_loader.set(config_delta)
+    end
+
+    def reset
+      @base_client.reset_channel!
+      @_stub = nil
+      @_stub_with_timeout = nil
     end
 
     def to_s
       @config_resolver.to_s
     end
 
+    def self.value_to_delta(key, config_value, namespace = nil)
+      Prefab::ConfigDelta.new(key: [namespace, key].compact.join(":"),
+                              value: config_value)
+    end
+
     private
 
     def stub
-      Prefab::ConfigService::Stub.new(nil,
-                                      nil,
-                                      channel_override: @base_client.channel,
-                                      interceptors: [@base_client.interceptor])
+      @_stub = Prefab::ConfigService::Stub.new(nil,
+                                               nil,
+                                               channel_override: @base_client.channel,
+                                               interceptors: [@base_client.interceptor])
     end
 
-    def stub_with_timout
-      Prefab::ConfigService::Stub.new(nil,
-                                      nil,
-                                      channel_override: @base_client.channel,
-                                      timeout: @timeout,
-                                      interceptors: [@base_client.interceptor])
+    def stub_with_timeout
+      @_stub_with_timeout = Prefab::ConfigService::Stub.new(nil,
+                                                            nil,
+                                                            channel_override: @base_client.channel,
+                                                            timeout: @timeout,
+                                                            interceptors: [@base_client.interceptor])
     end
 
-    def boot_resolver
-      config_req = Prefab::ConfigServicePointer.new(account_id: @base_client.account_id,
-                                                    start_at_id: 0)
+    def cache_key
+      "prefab:config:checkpoint"
+    end
+
+    # Bootstrap out of the cache
+    # returns the high-watermark of what was in the cache
+    def load_checkpoint
+      checkpoint = @base_client.shared_cache.read(cache_key)
+      start_at_id = 0
+
+      if checkpoint
+        deltas = Prefab::ConfigDeltas.decode(checkpoint)
+        deltas.deltas.each do |delta|
+          @base_client.logger.debug "checkpoint set #{delta.key} #{delta.value.int} #{delta.value.string} #{delta.id} "
+          @config_loader.set(delta)
+          start_at_id = [delta.id, start_at_id].max
+        end
+        @base_client.logger.info "Found checkpoint with highwater id #{start_at_id}"
+        @config_resolver.update
+      else
+        @base_client.logger.info "No checkpoint"
+      end
+
+      start_at_id
+    end
+
+    # A thread that saves current state to the cache, "checkpointing" it
+    def start_checkpointing_thread
+      Thread.new do
+        loop do
+          begin
+            started_at = Time.now
+            deltas = @config_resolver.export_api_deltas
+            @base_client.logger.debug "==CHECKPOINT==#{deltas.deltas.map {|d| d.id}.max}====="
+            @base_client.shared_cache.write(cache_key, Prefab::ConfigDeltas.encode(deltas))
+            delta = CHECKPOINT_FREQ_SEC - (Time.now - started_at)
+            if delta > 0
+              sleep(delta)
+            end
+          rescue StandardError => exn
+            @base_client.logger.info "Issue Checkpointing #{exn.message}"
+          end
+        end
+      end
+    end
 
+    # Setup a streaming connection to the API
+    # Save new config values into the loader
+    def start_api_connection_thread(start_at_id)
+      config_req = Prefab::ConfigServicePointer.new(account_id: @base_client.account_id,
+                                                    start_at_id: start_at_id)
       Thread.new do
         while true do
           begin
             resp = stub.get_config(config_req)
             resp.each do |r|
               r.deltas.each do |delta|
-                @config_resolver.set(delta, do_update: false)
+                @config_loader.set(delta)
               end
               @config_resolver.update
             end
           rescue => e
-            sleep(RECONNECT_WAIT)
             @base_client.logger.info("config client encountered #{e.message} pausing #{RECONNECT_WAIT}")
+            reset
+            sleep(RECONNECT_WAIT)
+          end
+        end
+      end
+    end
+
+    # Streaming connections don't guarantee all items have been seen
+    #
+    def start_suspenders_thread
+      start_at_suspenders = 0
+
+      Thread.new do
+        loop do
+          begin
+            started_at = Time.now
+            config_req = Prefab::ConfigServicePointer.new(account_id: @base_client.account_id,
+                                                          start_at_id: start_at_suspenders)
+            resp = stub_with_timeout.get_config(config_req)
+            resp.each do |r|
+              r.deltas.each do |delta|
+                @config_loader.set(delta)
+                start_at_suspenders = [start_at_suspenders, delta.id].max
+              end
+            end
+          rescue GRPC::DeadlineExceeded
+            # Ignore. This is a streaming endpoint, but we only need a single response
+          rescue => e
+            @base_client.logger.info "Suspenders encountered an issue #{e.message}"
+          end
+
+          delta = SUSPENDERS_FREQ_SEC - (Time.now - started_at)
+          if delta > 0
+            sleep(delta)
           end
         end
       end

data/lib/prefab/config_loader.rb

@@ -1,51 +1,77 @@
 require 'yaml'
-module EzConfig
+module Prefab
   class ConfigLoader
-    def initialize(logger)
-      @logger = logger
-      load_ez_config
-      load_project_config
-      load_local_overrides
+    def initialize(base_client)
+      @base_client = base_client
+      @classpath_config = load_classpath_config
+      @local_overrides = load_local_overrides
       @api_config = Concurrent::Map.new
-      @immutable_config = @ez_config.merge(@project_config)
     end
 
     def calc_config
-      rtn = @immutable_config.clone
+      rtn = @classpath_config.clone
       @api_config.each_key do |k|
-        rtn[k] = @api_config[k]
+        rtn[k] = @api_config[k].value
       end
       rtn = rtn.merge(@local_overrides)
       rtn
     end
 
     def set(delta)
-      @api_config[delta.key] = delta.value
+      @api_config[delta.key] = delta
+    end
+
+    def get_api_deltas
+      deltas = Prefab::ConfigDeltas.new
+      @api_config.each_value do |config_value|
+        deltas.deltas << config_value
+      end
+      deltas
     end
 
     private
 
-    def load_ez_config
-      @ez_config = load(".ezconfig.yaml")
+    def load_classpath_config
+      classpath_dir = ENV['PREFAB_CONFIG_CLASSPATH_DIR'] || ""
+      load_glob(File.join(classpath_dir, ".prefab*config.yaml"))
     end
 
-    def load_project_config
-      @project_config = load(".projectconfig.yaml")
+    def load_local_overrides
+      override_dir = ENV['PREFAB_CONFIG_OVERRIDE_DIR'] || Dir.home
+      load_glob(File.join(override_dir, ".prefab*config.yaml"))
     end
 
-    def load_local_overrides
-      @local_overrides = load(".ezconfig.overrides.yaml")
+    def load_glob(glob)
+      rtn = {}
+      Dir.glob(glob).each do |file|
+        yaml = load(file)
+        yaml.each do |k, v|
+          rtn[k] = Prefab::ConfigValue.new(value_from(v))
+        end
+      end
+      rtn
     end
 
     def load(filename)
       if File.exist? filename
-
         YAML.load_file(filename)
       else
-        @logger.info "No file #{filename}"
+        @base_client.logger.info "No file #{filename}"
         {}
       end
     end
 
+    def value_from(raw)
+      case raw
+      when String
+        {string: raw}
+      when Integer
+        {int: raw}
+      when TrueClass, FalseClass
+        {bool: raw}
+      when Float
+        {double: raw}
+      end
+    end
   end
 end

data/lib/prefab/config_resolver.rb

@@ -1,12 +1,12 @@
-module EzConfig
+module Prefab
   class ConfigResolver
 
-    def initialize(client)
+    def initialize(base_client, config_loader)
       @lock = Concurrent::ReadWriteLock.new
       @local_store = {}
-      @namespace = client.namespace
-      @config_loader = EzConfig::ConfigLoader.new(client.logger)
-      @logger = client.logger
+      @namespace = base_client.namespace
+      @config_loader = config_loader
+      @logger = base_client.logger
       make_local
     end
 
@@ -15,7 +15,7 @@ module EzConfig
       @lock.with_read_lock do
         @local_store.each do |k, v|
           value = v[:value]
-          str << "|#{k}| |#{value_of(value)}|\n"
+          str << "|#{k}| |#{value_of(value)}|#{value_of(value).class}\n"
         end
       end
       str
@@ -28,15 +28,14 @@ module EzConfig
       config ? value_of(config[:value]) : nil
     end
 
-    def set(delta, do_update: true)
-      @config_loader.set(delta)
-      update if do_update
-    end
-
     def update
       make_local
     end
 
+    def export_api_deltas
+      @config_loader.get_api_deltas
+    end
+
     private
 
     def value_of(config_value)
@@ -66,7 +65,7 @@ module EzConfig
           namespace = split[0]
         end
 
-        if (namespace == "") || namespace.start_with?(@namespace)
+        if (namespace == "") || @namespace.start_with?(namespace)
           existing = store[property]
           if existing.nil?
             store[property] = { namespace: namespace, value: value }

data/lib/prefab/feature_flag_client.rb

@@ -7,10 +7,7 @@ module Prefab
     end
 
     def upsert(feature_obj)
-      delta = Prefab::ConfigDelta.new(account_id: @base_client.account_id,
-                                      key: feature_config_name(feature_obj.feature),
-                                      value: Prefab::ConfigValue.new(feature_flag: feature_obj))
-      @base_client.config_client.set(delta)
+      @base_client.config_client.set(feature_config_name(feature_obj.feature), Prefab::ConfigValue.new(feature_flag: feature_obj))
     end
 
     def feature_is_on?(feature_name)
@@ -21,6 +18,12 @@ module Prefab
       @base_client.stats.increment("prefab.featureflag.on", tags: ["feature:#{feature_name}"])
 
       feature_obj = @base_client.config_client.get(feature_config_name(feature_name))
+      return is_on?(feature_name, lookup_key, attributes, feature_obj)
+    end
+
+    private
+
+    def is_on?(feature_name, lookup_key, attributes, feature_obj)
       if feature_obj.nil?
         return false
       end
@@ -37,11 +40,8 @@ module Prefab
       return feature_obj.pct > rand()
     end
 
-    private
-
-
     def get_user_pct(feature, lookup_key)
-      int_value = Murmur3.murmur3_32("#{@account_id}#{feature}#{lookup_key}")
+      int_value = Murmur3.murmur3_32("#{@base_client.account_id}#{feature}#{lookup_key}")
       int_value / MAX_32_FLOAT
     end
 

data/lib/prefab/ratelimit_client.rb

@@ -26,7 +26,7 @@ module Prefab
         allow_partial_response: allow_partial_response
       )
 
-      result = Retry.it(method(:stub), :limit_check, req, @timeout)
+      result = Retry.it(method(:stub), :limit_check, req, @timeout, method(:reset))
 
       reset = result.limit_reset_at
       @base_client.shared_cache.write(expiry_cache_key, reset) unless reset < 1 # protobuf default int to 0
@@ -41,12 +41,17 @@ module Prefab
 
     private
 
+    def reset
+      @base_client.reset_channel!
+      @_stub = nil
+    end
+
     def stub
-      Prefab::RateLimitService::Stub.new(nil,
-                                         nil,
-                                         channel_override: @base_client.channel,
-                                         timeout: @timeout,
-                                         interceptors: [@base_client.interceptor])
+      @_stub ||= Prefab::RateLimitService::Stub.new(nil,
+                                                    nil,
+                                                    channel_override: @base_client.channel,
+                                                    timeout: @timeout,
+                                                    interceptors: [@base_client.interceptor])
     end
 
     def handle_error(e, on_error, groups)

data/lib/prefab/retry.rb

@@ -5,21 +5,23 @@ class Retry
 
   # GRPC Generally handles timeouts for us
   # but if the connection is broken we want to retry up until the timeout
-  def self.it(stub_factory, rpc, req, timeout)
+  def self.it(stub_factory, rpc, req, timeout, reset)
     attempts = 0
     start_time = Time.now
 
     begin
       attempts += 1
-
       return stub_factory.call.send(rpc, req)
     rescue => exception
-      raise exception if Time.now - start_time > timeout
+      if Time.now - start_time > timeout
+        raise exception
+      end
 
       sleep_seconds = [BASE_SLEEP_SEC * (2 ** (attempts - 1)), MAX_SLEEP_SEC].min
       sleep_seconds = sleep_seconds * (0.5 * (1 + rand()))
       sleep_seconds = [BASE_SLEEP_SEC, sleep_seconds].max
       sleep sleep_seconds
+      reset.call
       retry
     end
   end

data/lib/prefab_pb.rb

@@ -9,7 +9,6 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     optional :start_at_id, :int64, 2
   end
   add_message "prefab.ConfigDelta" do
-    optional :account_id, :int64, 1
     optional :id, :int64, 2
     optional :key, :string, 3
     optional :value, :message, 4, "prefab.ConfigValue"
@@ -62,11 +61,9 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     value :MAXIMUM, 2
   end
   add_message "prefab.FeatureFlag" do
-    optional :account_id, :int64, 1
     optional :feature, :string, 2
     optional :pct, :double, 3
     repeated :whitelisted, :string, 4
-    optional :prior_feature_name, :string, 5
   end
   add_message "prefab.LimitDefinition" do
     optional :group, :string, 1

data/prefab-cloud-ruby.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: prefab-cloud-ruby 0.0.9 ruby lib
+# stub: prefab-cloud-ruby 0.0.10 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "0.0.9"
+  s.version = "0.0.10"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Jeff Dwyer".freeze]
-  s.date = "2017-12-22"
+  s.date = "2018-01-12"
   s.description = "RateLimits & Config as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.extra_rdoc_files = [
@@ -37,10 +37,14 @@ Gem::Specification.new do |s|
     "lib/prefab/noop_stats.rb",
     "lib/prefab/ratelimit_client.rb",
     "lib/prefab/retry.rb",
-    "lib/prefab/store.rb",
     "lib/prefab_pb.rb",
     "lib/prefab_services_pb.rb",
-    "prefab-cloud-ruby.gemspec"
+    "prefab-cloud-ruby.gemspec",
+    "test/.prefab.test.config.yaml",
+    "test/test_config_loader.rb",
+    "test/test_config_resolver.rb",
+    "test/test_feature_flag_client.rb",
+    "test/test_helper.rb"
   ]
   s.homepage = "http://github.com/prefab-cloud/prefab-cloud-ruby".freeze
   s.licenses = ["MIT".freeze]
@@ -51,18 +55,18 @@ Gem::Specification.new do |s|
     s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<grpc>.freeze, ["~> 1.7.3"])
+      s.add_runtime_dependency(%q<grpc>.freeze, ["~> 1.8.3"])
       s.add_runtime_dependency(%q<concurrent-ruby>.freeze, [">= 1.0.5", "~> 1.0"])
-      s.add_development_dependency(%q<grpc-tools>.freeze, ["~> 1.8"])
+      s.add_development_dependency(%q<grpc-tools>.freeze, ["~> 1.8.3"])
       s.add_development_dependency(%q<shoulda>.freeze, [">= 0"])
       s.add_development_dependency(%q<rdoc>.freeze, ["~> 3.12"])
       s.add_development_dependency(%q<bundler>.freeze, ["~> 1.0"])
       s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
       s.add_development_dependency(%q<simplecov>.freeze, [">= 0"])
     else
-      s.add_dependency(%q<grpc>.freeze, ["~> 1.7.3"])
+      s.add_dependency(%q<grpc>.freeze, ["~> 1.8.3"])
       s.add_dependency(%q<concurrent-ruby>.freeze, [">= 1.0.5", "~> 1.0"])
-      s.add_dependency(%q<grpc-tools>.freeze, ["~> 1.8"])
+      s.add_dependency(%q<grpc-tools>.freeze, ["~> 1.8.3"])
       s.add_dependency(%q<shoulda>.freeze, [">= 0"])
       s.add_dependency(%q<rdoc>.freeze, ["~> 3.12"])
       s.add_dependency(%q<bundler>.freeze, ["~> 1.0"])
@@ -70,9 +74,9 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<simplecov>.freeze, [">= 0"])
     end
   else
-    s.add_dependency(%q<grpc>.freeze, ["~> 1.7.3"])
+    s.add_dependency(%q<grpc>.freeze, ["~> 1.8.3"])
     s.add_dependency(%q<concurrent-ruby>.freeze, [">= 1.0.5", "~> 1.0"])
-    s.add_dependency(%q<grpc-tools>.freeze, ["~> 1.8"])
+    s.add_dependency(%q<grpc-tools>.freeze, ["~> 1.8.3"])
     s.add_dependency(%q<shoulda>.freeze, [">= 0"])
     s.add_dependency(%q<rdoc>.freeze, ["~> 3.12"])
     s.add_dependency(%q<bundler>.freeze, ["~> 1.0"])

data/test/.prefab.test.config.yaml

@@ -0,0 +1,5 @@
+sample: OneTwoThree
+sample_int: 123
+sample_double: 12.12
+sample_bool: true
+sample_to_override: Foo

data/test/test_config_loader.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class TestConfigLoader < Minitest::Test
+  def setup
+    ENV['PREFAB_CONFIG_OVERRIDE_DIR'] = "none"
+    ENV['PREFAB_CONFIG_CLASSPATH_DIR'] = "test"
+    @loader = Prefab::ConfigLoader.new(MockBaseClient.new)
+  end
+
+  def test_load
+    should_be :int, 123, "sample_int"
+    should_be :string, "OneTwoThree", "sample"
+    should_be :bool, true, "sample_bool"
+    should_be :double, 12.12, "sample_double"
+  end
+
+
+  def test_api_precedence
+    should_be :int, 123, "sample_int"
+
+    @loader.set(Prefab::ConfigDelta.new(key: "sample_int", value: Prefab::ConfigValue.new(int: 456)))
+    should_be :int, 456, "sample_int"
+
+  end
+
+  def test_api_deltas
+    val = Prefab::ConfigValue.new(int: 456)
+    delta = Prefab::ConfigDelta.new(key: "sample_int", value: val)
+    @loader.set(delta)
+
+    deltas = Prefab::ConfigDeltas.new
+    deltas.deltas << delta
+    assert_equal deltas, @loader.get_api_deltas
+  end
+
+  private
+
+  def should_be(type, value, key)
+    assert_equal type, @loader.calc_config[key].type
+    assert_equal value, @loader.calc_config[key].send(type)
+  end
+
+end

data/test/test_config_resolver.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class TestConfigResolver < Minitest::Test
+
+  def test_resolution
+    @loader = MockConfigLoader.new
+
+    loaded_values = {
+      "projectA:key" => Prefab::ConfigValue.new(string: "valueA"),
+      "key" => Prefab::ConfigValue.new(string: "value_none"),
+      "projectB:key" => Prefab::ConfigValue.new(string: "valueB"),
+      "projectB.subprojectX:key" => Prefab::ConfigValue.new(string: "projectB.subprojectX"),
+      "projectB.subprojectY:key" => Prefab::ConfigValue.new(string: "projectB.subprojectY"),
+      "projectB:key2" => Prefab::ConfigValue.new(string: "valueB2")
+    }
+
+    @loader.stub :calc_config, loaded_values do
+      @resolver = Prefab::ConfigResolver.new(MockBaseClient.new, @loader)
+      assert_equal "value_none", @resolver.get("key")
+
+
+      @resolverA = resolver_for_namespace("projectA", @loader)
+      assert_equal "valueA", @resolverA.get("key")
+
+      @resolverB = resolver_for_namespace("projectB", @loader)
+      assert_equal "valueB", @resolverB.get("key")
+
+      @resolverBX = resolver_for_namespace("projectB.subprojectX", @loader)
+      assert_equal "projectB.subprojectX", @resolverBX.get("key")
+
+      @resolverUndefinedSubProject = resolver_for_namespace("projectB.subprojectX:subsubQ", @loader)
+      assert_equal "projectB.subprojectX", @resolverBX.get("key")
+
+      @resolverBX = resolver_for_namespace("projectC", @loader)
+      assert_equal "value_none", @resolverBX.get("key")
+      assert_nil @resolverBX.get("key_that_doesnt_exist")
+    end
+  end
+
+  def resolver_for_namespace(namespace, loader)
+    Prefab::ConfigResolver.new(MockBaseClient.new(namespace: namespace), loader)
+  end
+
+end

data/test/test_feature_flag_client.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+class TestFeatureFlagClient < Minitest::Test
+
+  def test_pct
+    client = Prefab::FeatureFlagClient.new(MockBaseClient.new)
+    Prefab::FeatureFlagClient.send(:public, :is_on?)
+
+    flag = Prefab::FeatureFlag.new(feature: "FlagName", pct: 0.5)
+
+    assert_equal false,
+                 client.is_on?(flag.feature, "hashes high", [], flag)
+
+    assert_equal true,
+                 client.is_on?(flag.feature, "hashes low", [], flag)
+  end
+
+
+  def test_off
+    client = Prefab::FeatureFlagClient.new(MockBaseClient.new)
+    Prefab::FeatureFlagClient.send(:public, :is_on?)
+
+    flag = Prefab::FeatureFlag.new(feature: "FlagName", pct: 0)
+
+    assert_equal false,
+                 client.is_on?(flag.feature, "hashes high", [], flag)
+
+    assert_equal false,
+                 client.is_on?(flag.feature, "hashes low", [], flag)
+  end
+
+
+  def test_on
+    client = Prefab::FeatureFlagClient.new(MockBaseClient.new)
+    Prefab::FeatureFlagClient.send(:public, :is_on?)
+
+    flag = Prefab::FeatureFlag.new(feature: "FlagName", pct: 1)
+
+    assert_equal true,
+                 client.is_on?(flag.feature, "hashes high", [], flag)
+
+    assert_equal true,
+                 client.is_on?(flag.feature, "hashes low", [], flag)
+  end
+
+  def test_whitelist
+    client = Prefab::FeatureFlagClient.new(MockBaseClient.new)
+    Prefab::FeatureFlagClient.send(:public, :is_on?)
+
+    flag = Prefab::FeatureFlag.new(feature: "FlagName", pct: 0, whitelisted: ["beta", "user:1", "user:3"])
+
+    assert_equal false,
+                 client.is_on?(flag.feature, "anything", [], flag)
+    assert_equal true,
+                 client.is_on?(flag.feature, "anything", ["beta"], flag)
+    assert_equal true,
+                 client.is_on?(flag.feature, "anything", ["alpha", "beta"], flag)
+    assert_equal true,
+                 client.is_on?(flag.feature, "anything", ["alpha", "user:1"], flag)
+    assert_equal false,
+                 client.is_on?(flag.feature, "anything", ["alpha", "user:2"], flag)
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,21 @@
+require 'minitest/autorun'
+require 'prefab-cloud-ruby'
+
+class MockBaseClient
+  attr_reader :namespace, :logger
+
+  def initialize(namespace: "")
+    @namespace = namespace
+    @logger = Logger.new($stdout)
+  end
+
+  def account_id
+    1
+  end
+end
+
+class MockConfigLoader
+  def calc_config
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefab-cloud-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-22 00:00:00.000000000 Z
+date: 2018-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grpc
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.7.3
+        version: 1.8.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.7.3
+        version: 1.8.3
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -50,14 +50,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: 1.8.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: 1.8.3
 - !ruby/object:Gem::Dependency
   name: shoulda
   requirement: !ruby/object:Gem::Requirement
@@ -154,10 +154,14 @@ files:
 - lib/prefab/noop_stats.rb
 - lib/prefab/ratelimit_client.rb
 - lib/prefab/retry.rb
-- lib/prefab/store.rb
 - lib/prefab_pb.rb
 - lib/prefab_services_pb.rb
 - prefab-cloud-ruby.gemspec
+- test/.prefab.test.config.yaml
+- test/test_config_loader.rb
+- test/test_config_resolver.rb
+- test/test_feature_flag_client.rb
+- test/test_helper.rb
 homepage: http://github.com/prefab-cloud/prefab-cloud-ruby
 licenses:
 - MIT

data/lib/prefab/store.rb

@@ -1,29 +0,0 @@
-require "concurrent/atomics"
-
-module EzConfig
-  class Store
-    def initialize
-      @store = Concurrent::Map
-      @lock = Concurrent::ReadWriteLock.new
-    end
-
-    def get(key)
-      @lock.with_read_lock do
-        @store[key]
-      end
-    end
-
-    def all
-      @lock.with_read_lock do
-        @store.all
-      end
-    end
-
-    def init(fs)
-      @lock.with_write_lock do
-        @store.replace(fs)
-        @initialized.make_true
-      end
-    end
-  end
-end