rollout 2.6.2 → 3.1.0

data/spec/rollout/feature_state_spec.rb

@@ -0,0 +1,219 @@
+require "spec_helper"
+require "date"
+
+RSpec.describe Rollout::FeatureState do
+  def build_state(overrides = {})
+    described_class.new(**{
+      name: :chat,
+      percentage: 25,
+      users: [123, "456"],
+      groups: [:employees, "supporters"],
+      data: { description: "New navigation", "updated_at" => 1 },
+    }.merge(overrides))
+  end
+
+  def feature_for(state, options: {}, rollout: Object.new)
+    Rollout::Feature.new(state: state, rollout: rollout, options: options)
+  end
+
+  def json_value(value)
+    JSON.parse({ "value" => value }.to_json)["value"]
+  end
+
+  it "normalizes persistence types" do
+    state = build_state
+
+    expect(state.name).to eq "chat"
+    expect(state.percentage).to eq 25.0
+    expect(state.users).to eq %w[123 456]
+    expect(state.groups).to eq %w[employees supporters]
+    expect(state.data).to eq("description" => "New navigation", "updated_at" => 1)
+  end
+
+  it "does not share collections with the caller" do
+    users = ["123"]
+    groups = ["employees"]
+    nested = ["a"]
+    data = { "labels" => nested }
+    state = build_state(users: users, groups: groups, data: data)
+
+    users << "456"
+    groups << "supporters"
+    nested << "b"
+    data["labels"] << "c"
+
+    expect(state.users).to eq %w[123]
+    expect(state.groups).to eq %w[employees]
+    expect(state.data).to eq("labels" => ["a"])
+  end
+
+  it "canonicalizes nested JSON-compatible metadata" do
+    state = build_state(
+      data: {
+        "description" => "New navigation",
+        "updated_at" => 1,
+        "enabled" => true,
+        "ratio" => 0.5,
+        "owner" => nil,
+        "kind" => :beta,
+        "labels" => ["a", { "nested" => :ok }],
+      },
+    )
+
+    expect(state.data).to eq(
+      "description" => "New navigation",
+      "updated_at" => 1,
+      "enabled" => true,
+      "ratio" => 0.5,
+      "owner" => nil,
+      "kind" => "beta",
+      "labels" => ["a", { "nested" => "ok" }],
+    )
+  end
+
+  it "canonicalizes Time, Date, and custom JSON values" do
+    custom = Object.new
+    def custom.to_json(*)
+      '"widget"'
+    end
+
+    released_at = Time.utc(2026, 1, 1)
+    day = Date.new(2026, 1, 1)
+    state = build_state(
+      data: {
+        "released_at" => released_at,
+        "day" => day,
+        "item" => custom,
+      },
+    )
+
+    expect(state.data).to eq(
+      "released_at" => json_value(released_at),
+      "day" => json_value(day),
+      "item" => "widget",
+    )
+  end
+
+  it "canonicalizes BigDecimal through JSON" do
+    require "bigdecimal"
+
+    amount = BigDecimal("1.5")
+    state = build_state(data: { "amount" => amount })
+
+    expect(state.data).to eq("amount" => json_value(amount))
+  end
+
+  it "rejects metadata that cannot be serialized as JSON" do
+    cyclic = {}
+    cyclic["self"] = cyclic
+
+    expect {
+      build_state(data: cyclic)
+    }.to raise_error(JSON::JSONError)
+  end
+
+  it "rejects non-hash metadata" do
+    expect {
+      build_state(data: "nope")
+    }.to raise_error(ArgumentError, "data must be a Hash")
+  end
+
+  it "does not share nested data or strings with its clone" do
+    description = +"hello"
+    state = build_state(data: { "description" => description, "labels" => ["a"] })
+    clone = state.deep_clone
+
+    clone.users << "999"
+    clone.groups << "admins"
+    clone.data["labels"] << "b"
+    clone.data["description"] << "!"
+    description << "?"
+
+    expect(state.users).to eq %w[123 456]
+    expect(state.groups).to eq %w[employees supporters]
+    expect(state.data).to eq("description" => "hello", "labels" => ["a"])
+    expect(clone.data["description"]).to eq "hello!"
+  end
+
+  describe "Feature conversion" do
+    it "round-trips evaluation and metadata" do
+      rollout = Object.new
+      def rollout.active_in_group?(group, user)
+        group == :employees && user.id == 1
+      end
+
+      state = build_state(percentage: 20, users: ["42"], groups: ["employees"], data: { "description" => "New navigation" })
+      feature = feature_for(state, rollout: rollout)
+      restored = feature_for(feature.to_feature_state, rollout: rollout)
+
+      expect(feature.to_feature_state.name).to eq "chat"
+      expect(feature.to_feature_state.percentage).to eq 20.0
+      expect(feature.to_feature_state.users).to eq %w[42]
+      expect(feature.to_feature_state.groups).to eq %w[employees]
+      expect(feature.to_feature_state.data).to eq("description" => "New navigation")
+      expect(restored.name).to eq :chat
+
+      expect(restored.active?(double(id: 1))).to eq feature.active?(double(id: 1))
+      expect(restored.active?(double(id: 42))).to eq feature.active?(double(id: 42))
+      expect(restored.active?(double(id: 2))).to eq feature.active?(double(id: 2))
+      expect(restored.to_hash).to eq feature.to_hash
+    end
+
+    it "canonicalizes JSON-serializable metadata when converting a Feature" do
+      released_at = Time.utc(2026, 1, 1)
+      feature = feature_for(build_state)
+      feature.data["released_at"] = released_at
+      feature.data["kind"] = :beta
+
+      expect(feature.to_feature_state.data).to eq(
+        "description" => "New navigation",
+        "updated_at" => 1,
+        "released_at" => json_value(released_at),
+        "kind" => "beta",
+      )
+    end
+
+    it "does not share nested data with the source feature" do
+      feature = feature_for(build_state(data: { "labels" => ["a"] }))
+      state = feature.to_feature_state
+
+      feature.data["labels"] << "b"
+
+      expect(state.data).to eq("labels" => ["a"])
+    end
+
+    it "does not share nested data with a reconstructed feature" do
+      nested = ["a"]
+      state = build_state(data: { "labels" => nested })
+      feature = feature_for(state)
+
+      feature.data["labels"] << "b"
+      nested << "c"
+      state.data["labels"] << "d"
+
+      expect(feature.data).to eq("labels" => ["a", "b"])
+      expect(state.data).to eq("labels" => ["a", "d"])
+    end
+
+    it "uses sets when use_sets is enabled" do
+      feature = feature_for(build_state, options: { use_sets: true })
+
+      expect(feature.users).to eq %w[123 456].to_set
+      expect(feature.groups).to eq %i[employees supporters].to_set
+    end
+
+    it "preserves randomized percentage evaluation through a round trip" do
+      options = { randomize_percentage: true }
+      feature = feature_for(
+        Rollout::FeatureState.new(name: :chat, percentage: 20),
+        options: options,
+      )
+      restored = feature_for(feature.to_feature_state, options: options)
+
+      expect(restored.active?(double(id: 1))).to eq true
+      expect(restored.active?(double(id: 2))).to eq false
+      expect(restored.active?(double(id: 1))).to eq feature.active?(double(id: 1))
+      expect(restored.active?(double(id: 2))).to eq feature.active?(double(id: 2))
+    end
+  end
+end

data/spec/rollout/logging_spec.rb

@@ -1,143 +1,114 @@
-require 'spec_helper'
-
-RSpec.describe 'Rollout::Logging' do
-  let(:rollout) { Rollout.new($redis, logging: logging) }
-  let(:logging) { true }
-  let(:feature) { :foo }
-
-  it 'logs changes' do
-    expect(rollout.logging.last_event(feature)).to be_nil
-
-    rollout.activate_percentage(feature, 50)
-
-    expect(rollout.logging.updated_at(feature)).to_not be_nil
-
-    first_event = rollout.logging.last_event(feature)
-
-    expect(first_event.name).to eq 'update'
-    expect(first_event.data).to eq(before: { percentage: 0 }, after: { percentage: 50 })
-
-    rollout.activate_percentage(feature, 75)
-
-    second_event = rollout.logging.last_event(feature)
-
-    expect(second_event.name).to eq 'update'
-    expect(second_event.data).to eq(before: { percentage: 50 }, after: { percentage: 75 })
-
-    rollout.activate_group(feature, :hipsters)
+require "spec_helper"
+
+RSpec.describe "Rollout::Logging" do
+  def build_feature(percentage: 0, groups: [], users: [], data: {})
+    Rollout::Feature.new(
+      state: Rollout::FeatureState.new(
+        name: :foo,
+        percentage: percentage,
+        users: users,
+        groups: groups,
+        data: data,
+      ),
+      rollout: Object.new,
+      options: {},
+    )
+  end
 
-    third_event = rollout.logging.last_event(feature)
+  let(:logger) { Rollout::Logging::Logger.new(adapter: Object.new) }
 
-    expect(third_event.name).to eq 'update'
-    expect(third_event.data).to eq(before: { groups: [] }, after: { groups: ['hipsters'] })
+  it "does not respond to logging unless enabled" do
+    rollout = Rollout.new(adapter: Object.new)
 
-    expect(rollout.logging.events(feature)).to eq [first_event, second_event, third_event]
+    expect(rollout).not_to respond_to :logging
   end
 
-  context 'logging data changes' do
-    it 'logs changes' do
-      expect(rollout.logging.last_event(feature)).to be_nil
-
-      rollout.set_feature_data(feature, description: "foo")
 
-      event = rollout.logging.last_event(feature)
+  it "builds an event for percentage changes" do
+    event = logger.event_for(build_feature, build_feature(percentage: 50))
 
-      expect(event).not_to be_nil
-      expect(event.name).to eq 'update'
-      expect(event.data).to eq(before: { "data.description": nil }, after: { "data.description": "foo" })
-    end
+    expect(event.name).to eq :update
+    expect(event.data).to eq(before: { percentage: 0 }, after: { percentage: 50 })
   end
 
-  context 'no logging' do
-    let(:logging) { nil }
+  it "builds an event for metadata changes" do
+    event = logger.event_for(
+      build_feature,
+      build_feature(data: { "description" => "foo" }),
+    )
 
-    it 'doesnt even respond to logging' do
-      expect(rollout).not_to respond_to :logging
-    end
+    expect(event.data).to eq(before: { "data.description" => nil }, after: { "data.description" => "foo" })
   end
 
-  context 'history truncation' do
-    let(:logging) { { history_length: 1 } }
-
-    it 'logs changes' do
-      expect(rollout.logging.last_event(feature)).to be_nil
-
-      rollout.activate_percentage(feature, 25)
-
-      first_event = rollout.logging.last_event(feature)
-
-      expect(first_event.name).to eq 'update'
-      expect(first_event.data).to eq(before: { percentage: 0 }, after: { percentage: 25 })
+  it "does not build an event when nothing changes" do
+    feature = build_feature(percentage: 25)
 
-      rollout.activate_percentage(feature, 30)
-
-      second_event = rollout.logging.last_event(feature)
-
-      expect(second_event.name).to eq 'update'
-      expect(second_event.data).to eq(before: { percentage: 25 }, after: { percentage: 30 })
-
-      expect(rollout.logging.events(feature)).to eq [second_event]
-    end
+    expect(logger.event_for(feature, feature)).to be_nil
   end
 
-  context 'with context' do
-    let(:current_user) { double(nickname: 'lester') }
-
-    it 'adds context to the event' do
-      rollout.logging.with_context(actor: current_user.nickname) do
-        rollout.activate_percentage(feature, 25)
-      end
-
-      event = rollout.logging.last_event(feature)
-
-      expect(event.name).to eq 'update'
-      expect(event.data).to eq(before: { percentage: 0 }, after: { percentage: 25 })
-      expect(event.context).to eq(actor: current_user.nickname)
+  it "adds context to the event" do
+    event = nil
+    logger.with_context(actor: "lester") do
+      event = logger.event_for(build_feature, build_feature(percentage: 25))
     end
+
+    expect(event.context).to eq(actor: "lester")
   end
 
-  context 'global logs' do
-    let(:logging) { { global: true } }
-    let(:feature_foo) { 'foo' }
-    let(:feature_bar) { 'bar' }
+  it "does not build an event when logging is disabled" do
+    event = logger.without do
+      logger.event_for(build_feature, build_feature(percentage: 25))
+    end
 
-    it 'logs changes' do
-      expect(rollout.logging.last_event(feature_foo)).to be_nil
+    expect(event).to be_nil
+  end
 
-      rollout.activate_percentage(feature_foo, 25)
+  it "restores nested without state" do
+    nested_enabled = nil
+    outer_enabled = nil
 
-      event_foo = rollout.logging.last_event(feature_foo)
+    logger.without do
+      logger.without {}
+      nested_enabled = logger.logging_enabled?
+    end
+    outer_enabled = logger.logging_enabled?
 
-      expect(event_foo.feature).to eq feature_foo
-      expect(event_foo.name).to eq 'update'
-      expect(event_foo.data).to eq(before: { percentage: 0 }, after: { percentage: 25 })
+    expect(nested_enabled).to eq false
+    expect(outer_enabled).to eq true
+  end
 
-      expect(rollout.logging.events(feature_foo)).to eq [event_foo]
+  it "forwards a history limit to the backend" do
+    backend = double("backend")
+    logger = Rollout::Logging::Logger.new(adapter: backend)
+    events = [Object.new]
 
-      rollout.activate_percentage(feature_bar, 30)
+    expect(backend).to receive(:feature_events).with(:chat, limit: 2).and_return(events)
+    expect(logger.events(:chat, limit: 2)).to eq events
+  end
 
-      event_bar = rollout.logging.last_event(feature_bar)
+  it "requests one event for last_event" do
+    backend = double("backend")
+    logger = Rollout::Logging::Logger.new(adapter: backend)
+    event = Object.new
 
-      expect(event_bar.feature).to eq feature_bar
-      expect(event_bar.name).to eq 'update'
-      expect(event_bar.data).to eq(before: { percentage: 0 }, after: { percentage: 30 })
+    expect(backend).to receive(:feature_events).with(:chat, limit: 1).and_return([event])
+    expect(logger.last_event(:chat)).to eq event
+  end
 
-      expect(rollout.logging.events(feature_bar)).to eq [event_bar]
+  it "forwards a global history limit to the backend" do
+    backend = double("backend")
+    logger = Rollout::Logging::Logger.new(adapter: backend)
+    events = [Object.new]
 
-      expect(rollout.logging.global_events).to eq [event_foo, event_bar]
-    end
+    expect(backend).to receive(:global_events).with(limit: 2).and_return(events)
+    expect(logger.global_events(limit: 2)).to eq events
   end
 
-  context 'no logging for block' do
-    it 'doesnt log' do
-      rollout.logging.without do
-        rollout.activate_percentage(feature, 25)
-      end
-
-      event = rollout.logging.last_event(feature)
+  it "delegates history deletion" do
+    backend = double("backend")
+    logger = Rollout::Logging::Logger.new(adapter: backend)
 
-      expect(event).to be_nil
-    end
+    expect(backend).to receive(:delete_feature_events).with(:chat)
+    logger.delete(:chat)
   end
 end
-

data/spec/rollout/memory_backend_contract_spec.rb

@@ -0,0 +1,8 @@
+require "spec_helper"
+require "support/backend_contract"
+
+RSpec.describe RolloutMemoryBackend do
+  it_behaves_like "a rollout feature backend" do
+    let(:backend) { described_class.new }
+  end
+end