castle-rb 7.2.0 → 8.1.0

data/spec/lib/castle/client_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Castle::Client do
+RSpec.describe Castle::Client do
   let(:ip) { '1.2.3.4' }
   let(:cookie_id) { 'abcd' }
   let(:ua) { 'Chrome' }
@@ -9,20 +9,17 @@ describe Castle::Client do
       '/',
       'HTTP_USER_AGENT' => ua,
       'HTTP_X_FORWARDED_FOR' => ip,
-      'HTTP_COOKIE' => "__cid=#{cookie_id};other=efgh"
+      'HTTP_COOKIE' => "__cid=#{cookie_id};other=efgh",
+      'HTTP_CONTENT_LENGTH' => '0'
     )
   end
   let(:request) { Rack::Request.new(env) }
   let(:client) { described_class.from_request(request) }
   let(:request_to_context) { Castle::Context::Prepare.call(request) }
-  let(:client_with_user_timestamp) do
-    described_class.new(context: request_to_context, timestamp: time_user)
-  end
+  let(:client_with_user_timestamp) { described_class.new(context: request_to_context, timestamp: time_user) }
   let(:client_with_no_timestamp) { described_class.new(context: request_to_context) }
 
-  let(:headers) do
-    { 'Content-Length': '0', 'User-Agent': ua, 'X-Forwarded-For': ip.to_s, 'Cookie': true }
-  end
+  let(:headers) { { 'Content-Length': '0', 'User-Agent': ua, 'X-Forwarded-For': ip.to_s, Cookie: true } }
   let(:context) do
     {
       client_id: 'abcd',
@@ -44,9 +41,12 @@ describe Castle::Client do
   let(:response_code) { 200 }
 
   let(:stub_response) do
-    stub_request(:any, /api.castle.io/)
-      .with(basic_auth: ['', 'secret'])
-      .to_return(status: response_code, body: response_body, headers: {})
+    stub_request(:any, /api.castle.io/).with(basic_auth: ['', 'secret']).to_return(
+      status: response_code,
+      body: response_body,
+      headers: {
+      }
+    )
   end
 
   before do
@@ -95,9 +95,7 @@ describe Castle::Client do
     context 'when request is not successful' do
       let(:response_body) { {}.to_json }
 
-      it do
-        expect { client.end_impersonation(options) }.to raise_error(Castle::ImpersonationFailed)
-      end
+      it { expect { client.end_impersonation(options) }.to raise_error(Castle::ImpersonationFailed) }
     end
   end
 
@@ -130,9 +128,7 @@ describe Castle::Client do
     context 'when request is not successful' do
       let(:response_body) { {}.to_json }
 
-      it do
-        expect { client.start_impersonation(options) }.to raise_error(Castle::ImpersonationFailed)
-      end
+      it { expect { client.start_impersonation(options) }.to raise_error(Castle::ImpersonationFailed) }
     end
   end
 
@@ -140,13 +136,7 @@ describe Castle::Client do
     let(:options) { { event: '$login.succeeded', user_id: '1234' } }
     let(:request_response) { client.authenticate(options) }
     let(:request_body) do
-      {
-        event: '$login.succeeded',
-        user_id: '1234',
-        context: context,
-        timestamp: time_auto,
-        sent_at: time_auto
-      }
+      { event: '$login.succeeded', user_id: '1234', context: context, timestamp: time_auto, sent_at: time_auto }
     end
 
     context 'when used with symbol keys' do
@@ -162,13 +152,7 @@ describe Castle::Client do
         let(:client) { client_with_no_timestamp }
         let(:options) { { event: '$login.succeeded', user_id: '1234', timestamp: time_user } }
         let(:request_body) do
-          {
-            event: '$login.succeeded',
-            user_id: '1234',
-            context: context,
-            timestamp: time_user,
-            sent_at: time_auto
-          }
+          { event: '$login.succeeded', user_id: '1234', context: context, timestamp: time_user, sent_at: time_auto }
         end
 
         it do
@@ -181,13 +165,7 @@ describe Castle::Client do
       context 'with client initialized with timestamp' do
         let(:client) { client_with_user_timestamp }
         let(:request_body) do
-          {
-            event: '$login.succeeded',
-            user_id: '1234',
-            context: context,
-            timestamp: time_user,
-            sent_at: time_auto
-          }
+          { event: '$login.succeeded', user_id: '1234', context: context, timestamp: time_user, sent_at: time_auto }
         end
 
         it do
@@ -230,19 +208,15 @@ describe Castle::Client do
       end
 
       it { assert_not_requested :post, 'https://api.castle.io/v1/authenticate' }
-      it { expect(request_response[:policy][:action]).to be_eql(Castle::Verdict::ALLOW) }
-      it { expect(request_response[:action]).to be_eql(Castle::Verdict::ALLOW) }
-      it { expect(request_response[:user_id]).to be_eql('1234') }
+      it { expect(request_response[:policy][:action]).to eql(Castle::Verdict::ALLOW) }
+      it { expect(request_response[:action]).to eql(Castle::Verdict::ALLOW) }
+      it { expect(request_response[:user_id]).to eql('1234') }
       it { expect(request_response[:failover]).to be true }
-      it { expect(request_response[:failover_reason]).to be_eql('Castle is set to do not track.') }
+      it { expect(request_response[:failover_reason]).to eql('Castle is set to do not track.') }
     end
 
     context 'when request with fail' do
-      before do
-        allow(Castle::API).to receive(:send_request).and_raise(
-          Castle::RequestError.new(Timeout::Error)
-        )
-      end
+      before { allow(Castle::API).to receive(:send_request).and_raise(Castle::RequestError.new(Timeout::Error)) }
 
       context 'with request error and throw strategy' do
         before { allow(Castle.config).to receive(:failover_strategy).and_return(:throw) }
@@ -252,18 +226,16 @@ describe Castle::Client do
 
       context 'with request error and not throw on eg deny strategy' do
         it { assert_not_requested :post, 'https://:secret@api.castle.io/v1/authenticate' }
-        it { expect(request_response[:policy][:action]).to be_eql('allow') }
-        it { expect(request_response[:action]).to be_eql('allow') }
-        it { expect(request_response[:user_id]).to be_eql('1234') }
+        it { expect(request_response[:policy][:action]).to eql('allow') }
+        it { expect(request_response[:action]).to eql('allow') }
+        it { expect(request_response[:user_id]).to eql('1234') }
         it { expect(request_response[:failover]).to be true }
-        it { expect(request_response[:failover_reason]).to be_eql('Castle::RequestError') }
+        it { expect(request_response[:failover_reason]).to eql('Castle::RequestError') }
       end
     end
 
     context 'when request is internal server error' do
-      before do
-        allow(Castle::API).to receive(:send_request).and_raise(Castle::InternalServerError)
-      end
+      before { allow(Castle::API).to receive(:send_request).and_raise(Castle::InternalServerError) }
 
       describe 'throw strategy' do
         before { allow(Castle.config).to receive(:failover_strategy).and_return(:throw) }
@@ -273,24 +245,18 @@ describe Castle::Client do
 
       describe 'not throw on eg deny strategy' do
         it { assert_not_requested :post, 'https://:secret@api.castle.io/v1/authenticate' }
-        it { expect(request_response[:policy][:action]).to be_eql('allow') }
-        it { expect(request_response[:action]).to be_eql('allow') }
-        it { expect(request_response[:user_id]).to be_eql('1234') }
+        it { expect(request_response[:policy][:action]).to eql('allow') }
+        it { expect(request_response[:action]).to eql('allow') }
+        it { expect(request_response[:user_id]).to eql('1234') }
         it { expect(request_response[:failover]).to be true }
-        it { expect(request_response[:failover_reason]).to be_eql('Castle::InternalServerError') }
+        it { expect(request_response[:failover_reason]).to eql('Castle::InternalServerError') }
       end
     end
   end
 
   describe 'track' do
     let(:request_body) do
-      {
-        event: '$login.succeeded',
-        context: context,
-        user_id: '1234',
-        timestamp: time_auto,
-        sent_at: time_auto
-      }
+      { event: '$login.succeeded', context: context, user_id: '1234', timestamp: time_auto, sent_at: time_auto }
     end
 
     before { client.track(options) }
@@ -308,13 +274,7 @@ describe Castle::Client do
         let(:client) { client_with_no_timestamp }
         let(:options) { { event: '$login.succeeded', user_id: '1234', timestamp: time_user } }
         let(:request_body) do
-          {
-            event: '$login.succeeded',
-            user_id: '1234',
-            context: context,
-            timestamp: time_user,
-            sent_at: time_auto
-          }
+          { event: '$login.succeeded', user_id: '1234', context: context, timestamp: time_user, sent_at: time_auto }
         end
 
         it do
@@ -327,13 +287,7 @@ describe Castle::Client do
       context 'with client initialized with timestamp' do
         let(:client) { client_with_user_timestamp }
         let(:request_body) do
-          {
-            event: '$login.succeeded',
-            context: context,
-            user_id: '1234',
-            timestamp: time_user,
-            sent_at: time_auto
-          }
+          { event: '$login.succeeded', context: context, user_id: '1234', timestamp: time_user, sent_at: time_auto }
         end
 
         it do
@@ -380,4 +334,9 @@ describe Castle::Client do
   describe 'log' do
     it_behaves_like 'action request', :log
   end
+
+  describe 'client action mixins' do
+    it_behaves_like 'it has list actions'
+    it_behaves_like 'it has list item actions'
+  end
 end

data/spec/lib/castle/command_spec.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-describe Castle::Command do
+RSpec.describe Castle::Command do
   subject(:command) { described_class.new('go', { id: '1' }, :post) }
 
-  it { expect(command.path).to be_eql('go') }
-  it { expect(command.data).to be_eql(id: '1') }
-  it { expect(command.method).to be_eql(:post) }
+  it { expect(command.path).to eql('go') }
+  it { expect(command.data).to eql(id: '1') }
+  it { expect(command.method).to be(:post) }
 end

data/spec/lib/castle/commands/approve_device_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Castle::Commands::ApproveDevice do
+RSpec.describe Castle::Commands::ApproveDevice do
   subject(:instance) { described_class }
 
   let(:context) { {} }
@@ -16,8 +16,8 @@ describe Castle::Commands::ApproveDevice do
     end
 
     context 'with device_token' do
-      it { expect(command.method).to be_eql(:put) }
-      it { expect(command.path).to be_eql("devices/#{device_token}/approve") }
+      it { expect(command.method).to be(:put) }
+      it { expect(command.path).to eql("devices/#{device_token}/approve") }
       it { expect(command.data).to be_nil }
     end
   end

data/spec/lib/castle/commands/authenticate_spec.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-describe Castle::Commands::Authenticate do
+RSpec.describe Castle::Commands::Authenticate do
   subject(:instance) { described_class }
 
   let(:context) { { test: { test1: '1' } } }
-  let(:default_payload) do
-    { event: '$login.authenticate', user_id: '1234', sent_at: time_auto, context: context }
-  end
+  let(:default_payload) { { event: '$login.authenticate', user_id: '1234', sent_at: time_auto, context: context } }
 
   let(:time_now) { Time.now }
   let(:time_auto) { time_now.utc.iso8601(3) }
@@ -22,45 +20,45 @@ describe Castle::Commands::Authenticate do
       let(:payload) { default_payload.merge(properties: { test: '1' }) }
       let(:command_data) { default_payload.merge(properties: { test: '1' }, context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('authenticate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('authenticate') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'with user_traits' do
       let(:payload) { default_payload.merge(user_traits: { test: '1' }) }
       let(:command_data) { default_payload.merge(user_traits: { test: '1' }, context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('authenticate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('authenticate') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active true' do
       let(:payload) { default_payload.merge(context: context.merge(active: true)) }
       let(:command_data) { default_payload.merge(context: context.merge(active: true)) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('authenticate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('authenticate') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active false' do
       let(:payload) { default_payload.merge(context: context.merge(active: false)) }
       let(:command_data) { default_payload.merge(context: context.merge(active: false)) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('authenticate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('authenticate') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active string' do
       let(:payload) { default_payload.merge(context: context.merge(active: 'string')) }
       let(:command_data) { default_payload.merge(context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('authenticate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('authenticate') }
+      it { expect(command.data).to eql(command_data) }
     end
   end
 
@@ -70,12 +68,7 @@ describe Castle::Commands::Authenticate do
     context 'with event not present' do
       let(:payload) { {} }
 
-      it do
-        expect { validate! }.to raise_error(
-          Castle::InvalidParametersError,
-          'event is missing or empty'
-        )
-      end
+      it { expect { validate! }.to raise_error(Castle::InvalidParametersError, 'event is missing or empty') }
     end
 
     context 'with user_id not present' do

data/spec/lib/castle/commands/end_impersonation_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Castle::Commands::EndImpersonation do
+RSpec.describe Castle::Commands::EndImpersonation do
   subject(:instance) { described_class }
 
   let(:context) { { user_agent: 'test', ip: '127.0.0.1', client_id: 'test' } }
@@ -19,40 +19,38 @@ describe Castle::Commands::EndImpersonation do
 
     context 'with impersonator' do
       let(:payload) { default_payload.merge(properties: { impersonator: impersonator }) }
-      let(:command_data) do
-        default_payload.merge(properties: { impersonator: impersonator }, context: context)
-      end
+      let(:command_data) { default_payload.merge(properties: { impersonator: impersonator }, context: context) }
 
-      it { expect(command.method).to be_eql(:delete) }
-      it { expect(command.path).to be_eql('impersonate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:delete) }
+      it { expect(command.path).to eql('impersonate') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active true' do
       let(:payload) { default_payload.merge(context: context.merge(active: true)) }
       let(:command_data) { default_payload.merge(context: context.merge(active: true)) }
 
-      it { expect(command.method).to be_eql(:delete) }
-      it { expect(command.path).to be_eql('impersonate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:delete) }
+      it { expect(command.path).to eql('impersonate') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active false' do
       let(:payload) { default_payload.merge(context: context.merge(active: false)) }
       let(:command_data) { default_payload.merge(context: context.merge(active: false)) }
 
-      it { expect(command.method).to be_eql(:delete) }
-      it { expect(command.path).to be_eql('impersonate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:delete) }
+      it { expect(command.path).to eql('impersonate') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active string' do
       let(:payload) { default_payload.merge(context: context.merge(active: 'string')) }
       let(:command_data) { default_payload.merge(context: context) }
 
-      it { expect(command.method).to be_eql(:delete) }
-      it { expect(command.path).to be_eql('impersonate') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:delete) }
+      it { expect(command.path).to eql('impersonate') }
+      it { expect(command.data).to eql(command_data) }
     end
   end
 
@@ -62,12 +60,7 @@ describe Castle::Commands::EndImpersonation do
     context 'when user_id not present' do
       let(:payload) { {} }
 
-      it do
-        expect { validate! }.to raise_error(
-          Castle::InvalidParametersError,
-          'user_id is missing or empty'
-        )
-      end
+      it { expect { validate! }.to raise_error(Castle::InvalidParametersError, 'user_id is missing or empty') }
     end
 
     context 'when user_id present' do

data/spec/lib/castle/commands/filter_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Castle::Commands::Filter do
+RSpec.describe Castle::Commands::Filter do
   subject(:instance) { described_class }
 
   let(:context) { { test: { test1: '1' } } }
@@ -28,45 +28,45 @@ describe Castle::Commands::Filter do
       let(:payload) { default_payload.merge(properties: { test: '1' }) }
       let(:command_data) { default_payload.merge(properties: { test: '1' }, context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('filter') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('filter') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'with user_traits' do
       let(:payload) { default_payload.merge(user_traits: { test: '1' }) }
       let(:command_data) { default_payload.merge(user_traits: { test: '1' }, context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('filter') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('filter') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active true' do
       let(:payload) { default_payload.merge(context: context.merge(active: true)) }
       let(:command_data) { default_payload.merge(context: context.merge(active: true)) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('filter') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('filter') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active false' do
       let(:payload) { default_payload.merge(context: context.merge(active: false)) }
       let(:command_data) { default_payload.merge(context: context.merge(active: false)) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('filter') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('filter') }
+      it { expect(command.data).to eql(command_data) }
     end
 
     context 'when active string' do
       let(:payload) { default_payload.merge(context: context.merge(active: 'string')) }
       let(:command_data) { default_payload.merge(context: context) }
 
-      it { expect(command.method).to be_eql(:post) }
-      it { expect(command.path).to be_eql('filter') }
-      it { expect(command.data).to be_eql(command_data) }
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('filter') }
+      it { expect(command.data).to eql(command_data) }
     end
   end
 end

data/spec/lib/castle/commands/get_device_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Castle::Commands::GetDevice do
+RSpec.describe Castle::Commands::GetDevice do
   subject(:instance) { described_class }
 
   let(:context) { {} }
@@ -16,8 +16,8 @@ describe Castle::Commands::GetDevice do
     end
 
     context 'with device_token' do
-      it { expect(command.method).to be_eql(:get) }
-      it { expect(command.path).to be_eql("devices/#{device_token}") }
+      it { expect(command.method).to be(:get) }
+      it { expect(command.path).to eql("devices/#{device_token}") }
       it { expect(command.data).to be_nil }
     end
   end

data/spec/lib/castle/commands/get_devices_for_user_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Castle::Commands::GetDevicesForUser do
+RSpec.describe Castle::Commands::GetDevicesForUser do
   subject(:instance) { described_class }
 
   let(:context) { {} }
@@ -16,8 +16,8 @@ describe Castle::Commands::GetDevicesForUser do
     end
 
     context 'with user_id' do
-      it { expect(command.method).to be_eql(:get) }
-      it { expect(command.path).to be_eql("users/#{user_id}/devices") }
+      it { expect(command.method).to be(:get) }
+      it { expect(command.path).to eql("users/#{user_id}/devices") }
       it { expect(command.data).to be_nil }
     end
   end

data/spec/lib/castle/commands/list_items/archive_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+RSpec.describe Castle::Commands::ListItems::Archive do
+  describe '.build' do
+    subject(:command) { described_class.build(options) }
+
+    context 'with valid options' do
+      let(:options) { { list_id: 'list_id', list_item_id: 'list_item_id'} }
+
+      it { expect(command.method).to be(:delete) }
+      it { expect(command.path).to eql('lists/list_id/items/list_item_id/archive') }
+      it { expect(command.data).to be_nil }
+    end
+
+    context 'with invalid options' do
+      let(:options) { { list_id: 'list_id' } }
+
+      it { expect { command }.to raise_error(Castle::InvalidParametersError) }
+    end
+  end
+end

data/spec/lib/castle/commands/list_items/count_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+RSpec.describe Castle::Commands::ListItems::Count do
+  describe '.build' do
+    subject(:command) { described_class.build(options) }
+
+    context 'with valid options' do
+      let(:options) { { list_id: 'list_id', filters: [{ field: 'primary_value', op: '$eq', value: 'test'}]} }
+
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('lists/list_id/items/count') }
+      it { expect(command.data).to eql(options.except(:list_id)) }
+    end
+
+    context 'with invalid filters' do
+      let(:options) { { list_id: 'list_id', filters: [{ field: 'primary_field', op: '$eq' }]} }
+
+      it { expect { command }.to raise_error(Castle::InvalidParametersError) }
+    end
+  end
+end

data/spec/lib/castle/commands/list_items/create_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+RSpec.describe Castle::Commands::ListItems::Create do
+  describe '.build' do
+    subject(:command) { described_class.build(options) }
+
+    context 'with valid options' do
+      let(:author) { { type: '$other', identifier: 'some value' } }
+      let(:options) { { list_id: 'list_id', author: author, primary_value: 'some value' } }
+
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('lists/list_id/items') }
+      it { expect(command.data).to eql(options.except(:list_id)) }
+    end
+
+    context 'with invalid options' do
+      let(:options) { { list_id: 'list_id' } }
+
+      it { expect { command }.to raise_error(Castle::InvalidParametersError) }
+    end
+  end
+end

data/spec/lib/castle/commands/list_items/get_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+RSpec.describe Castle::Commands::ListItems::Get do
+  describe '.build' do
+    subject(:command) { described_class.build(options) }
+
+    context 'with valid options' do
+      let(:options) { { list_id: 'list_id', list_item_id: 'list_item_id'} }
+
+      it { expect(command.method).to be(:get) }
+      it { expect(command.path).to eql('lists/list_id/items/list_item_id') }
+      it { expect(command.data).to be_nil }
+    end
+
+    context 'with invalid options' do
+      let(:options) { { list_id: 'list_id' } }
+
+      it { expect { command }.to raise_error(Castle::InvalidParametersError) }
+    end
+  end
+end

data/spec/lib/castle/commands/list_items/query_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe Castle::Commands::ListItems::Query do
+  describe '.build' do
+    subject(:command) { described_class.build(options) }
+
+    context 'with valid options' do
+      let(:options) { { list_id: 'list_id', filters: [{ field: 'primary_value', op: '$eq', value: 'test'}]} }
+
+      it { expect(command.method).to be(:post) }
+      it { expect(command.path).to eql('lists/list_id/items/query') }
+      it { expect(command.data).to eql(options.except(:list_id)) }
+    end
+
+    context 'with invalid filters' do
+      let(:options) { { list_id: 'list_id', filters: [{ field: 'primary_field', op: '$eq' }]} }
+
+      it { expect { command }.to raise_error(Castle::InvalidParametersError) }
+    end
+
+    context 'with no list_id' do
+      let(:options) { { filters: [{ field: 'primary_field', op: '$eq', value: 'test' }]} }
+
+      it { expect { command }.to raise_error(Castle::InvalidParametersError) }
+    end
+  end
+end