feat: add test for notifications_muted as filter in query_members (#140)

* feat: add test for `notifications_muted` as filter in `query_members`

Signed-off-by: Federico Guerinoni <[email protected]>

* fix: adjust style

* fix: binding

* fix: remove old campaigns test

* chore: remove old campaign

---------

Signed-off-by: Federico Guerinoni <[email protected]>

Author: guerinoni

README.md

@@ -165,32 +165,6 @@ status_response = client.get_export_channel_status(response['task_id'])
 # status_response['status'] == 'pending', 'completed'
 ```
 
-### Campaigns
-
-```ruby
-# Create a user or channel segment
-client.create_segment({ name: 'test', type: 'user', filter: { uniq: 'a flag on users' } })
-
-# Create a campaign that uses the segment
-client.create_campaign({
-    name: 'test',
-    text: 'Hi',
-    sender_id: campaign_sender,
-    segment_id: segment_id,
-    channel_type: 'messaging'
-})
-
-# Schedule the campaign
-client.schedule_campaign(campaign_id, Time.now.to_i)
-
-# Query the campaign to check the status
-response = client.query_campaigns(filter_conditions: { id: campaign_id })
-response['campaigns'][0]['status'] == 'completed'
-
-# Read sent information
-client.query_recipients(filter_conditions: { campaign_id: campaign_id })
-```
-
 ### Rate limits
 
 ```ruby

lib/stream-chat/client.rb

@@ -258,13 +258,13 @@ def delete_user(user_id, **options)
     # Restores a user synchronously.
     sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def restore_user(user_id)
-      post("users/restore", data: { user_ids: [user_id] })
+      post('users/restore', data: { user_ids: [user_id] })
     end
 
     # Restores users synchronously.
     sig { params(user_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
     def restore_users(user_ids)
-      post("users/restore", data: { user_ids: user_ids })
+      post('users/restore', data: { user_ids: user_ids })
     end
 
     # Deactivates a user.
@@ -681,13 +681,13 @@ def revoke_users_token(user_ids, before)
       before = T.cast(before, DateTime).rfc3339 if before.instance_of?(DateTime)
 
       updates = []
-      user_ids.each do |user_id|
-        updates.push({
-                       'id' => user_id,
-                       'set' => {
-                         'revoke_tokens_issued_before' => before
-                       }
-                     })
+      user_ids.map do |user_id|
+        {
+          'id' => user_id,
+          'set' => {
+            'revoke_tokens_issued_before' => before
+          }
+        }
       end
       update_users_partial(updates)
     end
@@ -890,84 +890,6 @@ def list_imports(options)
       get('imports', params: options)
     end
 
-    # Creates a campaign.
-    sig { params(campaign: StringKeyHash).returns(StreamChat::StreamResponse) }
-    def create_campaign(campaign)
-      post('campaigns', data: { campaign: campaign })
-    end
-
-    # Queries campaigns similar to query_channels or query_users.
-    sig { params(params: T.untyped).returns(StreamChat::StreamResponse) }
-    def query_campaigns(**params)
-      get('campaigns', params: { payload: params.to_json })
-    end
-
-    # Updates a campaign.
-    sig { params(campaign_id: String, campaign: StringKeyHash).returns(StreamChat::StreamResponse) }
-    def update_campaign(campaign_id, campaign)
-      put("campaigns/#{campaign_id}", data: { campaign: campaign })
-    end
-
-    # Deletes a campaign.
-    sig { params(campaign_id: String).returns(StreamChat::StreamResponse) }
-    def delete_campaign(campaign_id)
-      delete("campaigns/#{campaign_id}")
-    end
-
-    # Schedules a campaign.
-    sig { params(campaign_id: String, scheduled_for: Integer).returns(StreamChat::StreamResponse) }
-    def schedule_campaign(campaign_id, scheduled_for)
-      patch("campaigns/#{campaign_id}/schedule", data: { scheduled_for: scheduled_for })
-    end
-
-    # Stops a campaign.
-    sig { params(campaign_id: String).returns(StreamChat::StreamResponse) }
-    def stop_campaign(campaign_id)
-      patch("campaigns/#{campaign_id}/stop")
-    end
-
-    # Resumes a campaign.
-    sig { params(campaign_id: String).returns(StreamChat::StreamResponse) }
-    def resume_campaign(campaign_id)
-      patch("campaigns/#{campaign_id}/resume")
-    end
-
-    # Tests a campaign.
-    sig { params(campaign_id: String, users: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
-    def test_campaign(campaign_id, users)
-      post("campaigns/#{campaign_id}/test", data: { users: users })
-    end
-
-    # Creates a campaign segment.
-    sig { params(segment: StringKeyHash).returns(StreamChat::StreamResponse) }
-    def create_segment(segment)
-      post('segments', data: { segment: segment })
-    end
-
-    # Queries campaign segments.
-    sig { params(params: T.untyped).returns(StreamChat::StreamResponse) }
-    def query_segments(**params)
-      get('segments', params: { payload: params.to_json })
-    end
-
-    # Updates a campaign segment.
-    sig { params(segment_id: String, segment: StringKeyHash).returns(StreamChat::StreamResponse) }
-    def update_segment(segment_id, segment)
-      put("segments/#{segment_id}", data: { segment: segment })
-    end
-
-    # Deletes a campaign segment.
-    sig { params(segment_id: String).returns(StreamChat::StreamResponse) }
-    def delete_segment(segment_id)
-      delete("segments/#{segment_id}")
-    end
-
-    # Queries campaign recipients.
-    sig { params(params: T.untyped).returns(StreamChat::StreamResponse) }
-    def query_recipients(**params)
-      get('recipients', params: { payload: params.to_json })
-    end
-
     private
 
     sig { returns(T::Hash[String, String]) }

sorbet/rbi/hidden-definitions/hidden.rbi

@@ -774,12 +774,6 @@ class BigDecimal
   def self.ver(); end
 end
 
-class Binding
-  def clone(); end
-
-  def irb(); end
-end
-
 class Bundler::APIResponseInvalidDependenciesError
   def status_code(); end
 end

spec/channel_spec.rb

@@ -284,5 +284,8 @@ def loop_times(times)
 
     response = @channel.query_members(limit: 1)
     expect(response['members'].length).to eq 1
+
+    response = @channel.query_members(filter_conditions: { notifications_muted: true })
+    expect(response['members'].length).to eq 2
   end
 end

spec/client_spec.rb

@@ -735,39 +735,6 @@ def loop_times(times)
     end
   end
 
-  describe 'campaigns', campaigns: true do
-    before(:all) do
-      @campaign_selector = SecureRandom.uuid
-      @campaign_receiver = SecureRandom.uuid
-      @campaign_sender = SecureRandom.uuid
-      @client.upsert_user({ id: @campaign_receiver, uniq: @campaign_selector, receiver: true })
-      @client.upsert_user({ id: @campaign_sender, sender: true })
-    end
-
-    it 'full flow' do
-      response = @client.create_segment({ name: 'test', type: 'user', filter: { uniq: @campaign_selector } })
-      segment = response['segment']
-      response = @client.create_campaign({ name: 'test', text: 'Hi', sender_id: @campaign_sender, segment_id: segment['id'], channel_type: 'messaging' })
-      campaign = response['campaign']
-      @client.schedule_campaign(campaign['id'], Time.now.to_i)
-
-      response = @client.query_segments(filter_conditions: { id: segment['id'] })
-      expect(response['segments'].length).to eq 1
-
-      loop do
-        response = @client.query_campaigns(filter_conditions: { id: campaign['id'] })
-        if response['campaigns'].length == 1 && response['campaigns'][0]['status'] == 'completed'
-          response = @client.query_recipients(filter_conditions: { campaign_id: campaign['id'] })
-          puts response.to_json
-          expect(response['recipients'].length).to eq 1
-          expect(response['recipients'][0]['receiver_id']).to eq @campaign_receiver
-          break
-        end
-        sleep(0.5)
-      end
-    end
-  end
-
   describe 'permissions' do
     before(:all) do
       @permission_id = SecureRandom.uuid