workos 10.4.0 → 10.6.0

data/test/workos/test_sso_model_round_trip.rb

@@ -187,6 +187,7 @@ class SsoModelRoundTripTest < Minitest::Test
       "client_secret" => "stub",
       "code" => "stub",
       "grant_type" => "stub",
+      "code_verifier" => "stub",
       "subject_token" => "stub",
       "subject_token_type" => "urn:ietf:params:oauth:token-type:id_token",
       "organization_id" => "stub"
@@ -199,6 +200,66 @@ class SsoModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
+  def test_connection_finish_error_body_round_trip
+    fixture = {
+      "code" => "stub",
+      "message" => "stub"
+    }
+    model = WorkOS::ConnectionFinishErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_connection_creation_not_found_error_body_round_trip
+    fixture = {
+      "code" => "stub",
+      "message" => "stub"
+    }
+    model = WorkOS::ConnectionCreationNotFoundErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_connection_creation_conflict_error_body_round_trip
+    fixture = {
+      "code" => "stub",
+      "message" => "stub"
+    }
+    model = WorkOS::ConnectionCreationConflictErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_connection_could_not_be_verified_error_body_round_trip
+    fixture = {
+      "code" => "connection_could_not_be_verified",
+      "message" => "stub"
+    }
+    model = WorkOS::ConnectionCouldNotBeVerifiedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_connection_type_not_updatable_error_body_round_trip
+    fixture = {
+      "code" => "connection_type_not_updatable",
+      "message" => "stub"
+    }
+    model = WorkOS::ConnectionTypeNotUpdatableErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
   def test_connection_round_trip
     fixture = {
       "object" => "connection",

data/test/workos/test_user_management_model_round_trip.rb

@@ -74,7 +74,8 @@ class UserManagementModelRoundTripTest < Minitest::Test
       "ip_address" => "stub",
       "user_agent" => "stub",
       "radar_auth_attempt_id" => "stub",
-      "signals_id" => "stub"
+      "signals_id" => "stub",
+      "locale" => "stub"
     }
     model = WorkOS::CreateMagicCodeAndReturn.new(fixture.to_json)
     json = model.to_h
@@ -169,6 +170,16 @@ class UserManagementModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
+  def test_send_verification_email_round_trip
+    fixture = {
+      "locale" => "stub"
+    }
+    model = WorkOS::SendVerificationEmail.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
   def test_verify_email_address_round_trip
     fixture = {
       "code" => "stub"
@@ -182,7 +193,8 @@ class UserManagementModelRoundTripTest < Minitest::Test
 
   def test_create_password_reset_token_round_trip
     fixture = {
-      "email" => "stub"
+      "email" => "stub",
+      "locale" => "stub"
     }
     model = WorkOS::CreatePasswordResetToken.new(fixture.to_json)
     json = model.to_h
@@ -206,7 +218,8 @@ class UserManagementModelRoundTripTest < Minitest::Test
 
   def test_send_email_change_round_trip
     fixture = {
-      "new_email" => "stub"
+      "new_email" => "stub",
+      "locale" => "stub"
     }
     model = WorkOS::SendEmailChange.new(fixture.to_json)
     json = model.to_h
@@ -250,6 +263,262 @@ class UserManagementModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
+  def test_user_connected_account_import_error_body_round_trip
+    fixture = {
+      "code" => "stub",
+      "message" => "stub"
+    }
+    model = WorkOS::UserConnectedAccountImportErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_email_completion_required_error_body_with_email_completion_token_round_trip
+    fixture = {
+      "code" => "email_completion_required",
+      "message" => "stub",
+      "email_completion_token" => "stub"
+    }
+    model = WorkOS::EmailCompletionRequiredErrorBodyWithEmailCompletionToken.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    assert_equal fixture["email_completion_token"], json[:email_completion_token]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_user_consent_options_not_supported_error_body_round_trip
+    fixture = {
+      "code" => "user_consent_options_not_supported",
+      "message" => "stub"
+    }
+    model = WorkOS::UserConsentOptionsNotSupportedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_email_change_not_allowed_error_body_round_trip
+    fixture = {
+      "code" => "email_change_not_allowed",
+      "message" => "stub"
+    }
+    model = WorkOS::EmailChangeNotAllowedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_email_not_available_error_body_round_trip
+    fixture = {
+      "code" => "email_not_available",
+      "message" => "stub"
+    }
+    model = WorkOS::EmailNotAvailableErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_email_already_in_use_error_body_round_trip
+    fixture = {
+      "code" => "email_already_in_use",
+      "message" => "stub"
+    }
+    model = WorkOS::EmailAlreadyInUseErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invitation_invalid_oauth_error_body_round_trip
+    fixture = {
+      "error" => "invitation_invalid",
+      "error_description" => "stub"
+    }
+    model = WorkOS::InvitationInvalidOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_authentication_method_not_allowed_oauth_error_body_round_trip
+    fixture = {
+      "error" => "authentication_method_not_allowed",
+      "error_description" => "stub"
+    }
+    model = WorkOS::AuthenticationMethodNotAllowedOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_email_domain_not_deliverable_error_body_round_trip
+    fixture = {
+      "code" => "email_domain_not_deliverable",
+      "message" => "stub"
+    }
+    model = WorkOS::EmailDomainNotDeliverableErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_password_strength_error_error_body_with_errors_round_trip
+    fixture = {
+      "code" => "password_strength_error",
+      "message" => "stub",
+      "errors" => []
+    }
+    model = WorkOS::PasswordStrengthErrorErrorBodyWithErrors.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_user_creation_error_error_body_with_errors_round_trip
+    fixture = {
+      "code" => "user_creation_error",
+      "message" => "stub",
+      "errors" => []
+    }
+    model = WorkOS::UserCreationErrorErrorBodyWithErrors.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_password_and_password_hash_provided_error_body_round_trip
+    fixture = {
+      "code" => "password_and_password_hash_provided",
+      "message" => "stub"
+    }
+    model = WorkOS::PasswordAndPasswordHashProvidedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_password_and_password_hash_type_provided_error_body_round_trip
+    fixture = {
+      "code" => "password_and_password_hash_type_provided",
+      "message" => "stub"
+    }
+    model = WorkOS::PasswordAndPasswordHashTypeProvidedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_password_salt_position_requires_password_hash_error_body_round_trip
+    fixture = {
+      "code" => "password_salt_position_requires_password_hash",
+      "message" => "stub"
+    }
+    model = WorkOS::PasswordSaltPositionRequiresPasswordHashErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_email_already_verified_error_body_round_trip
+    fixture = {
+      "code" => "email_already_verified",
+      "message" => "stub"
+    }
+    model = WorkOS::EmailAlreadyVerifiedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_user_mismatch_error_body_round_trip
+    fixture = {
+      "code" => "user_mismatch",
+      "message" => "stub"
+    }
+    model = WorkOS::UserMismatchErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_invitation_cannot_be_used_for_email_oauth_error_body_round_trip
+    fixture = {
+      "error" => "invitation_cannot_be_used_for_email",
+      "error_description" => "stub"
+    }
+    model = WorkOS::InvitationCannotBeUsedForEmailOAuthErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["error_description"], json[:error_description]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_authentication_method_not_allowed_error_body_round_trip
+    fixture = {
+      "code" => "authentication_method_not_allowed",
+      "message" => "stub"
+    }
+    model = WorkOS::AuthenticationMethodNotAllowedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_email_verification_required_error_body_round_trip
+    fixture = {
+      "code" => "email_verification_required",
+      "message" => "stub"
+    }
+    model = WorkOS::EmailVerificationRequiredErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_email_password_auth_disabled_error_body_round_trip
+    fixture = {
+      "code" => "email_password_auth_disabled",
+      "message" => "stub"
+    }
+    model = WorkOS::EmailPasswordAuthDisabledErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_action_denied_error_body_round_trip
+    fixture = {
+      "code" => "action_denied",
+      "message" => "stub"
+    }
+    model = WorkOS::ActionDeniedErrorBody.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["message"], json[:message]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
   def test_user_round_trip
     fixture = {
       "object" => "user",
@@ -2693,4 +2962,29 @@ class UserManagementModelRoundTripTest < Minitest::Test
     assert_nil json[:reason]
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
+
+  def test_waitlist_list_response_round_trip
+    fixture = {
+      "object" => "list",
+      "data" => [],
+      "list_metadata" => {}
+    }
+    model = WorkOS::WaitlistListResponse.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_waitlist_list_response_list_metadata_round_trip
+    fixture = {
+      "before" => nil,
+      "after" => nil
+    }
+    model = WorkOS::WaitlistListResponseListMetadata.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_nil json[:before]
+    assert_nil json[:after]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
 end

data/test/workos/test_vault_model_round_trip.rb

@@ -131,6 +131,25 @@ class VaultModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
+  def test_object_version_round_trip
+    fixture = {
+      "created_at" => "stub",
+      "current_version" => true,
+      "etag" => "stub",
+      "id" => "stub",
+      "size" => 1
+    }
+    model = WorkOS::ObjectVersion.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["created_at"], json[:created_at]
+    assert_equal fixture["current_version"], json[:current_version]
+    assert_equal fixture["etag"], json[:etag]
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["size"], json[:size]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
   def test_object_without_value_round_trip
     fixture = {
       "id" => "stub",
@@ -169,6 +188,17 @@ class VaultModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
+  def test_version_list_response_round_trip
+    fixture = {
+      "data" => [],
+      "list_metadata" => {}
+    }
+    model = WorkOS::VersionListResponse.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
   def test_vault_byok_key_deleted_round_trip
     fixture = {
       "object" => "event",
@@ -435,6 +465,39 @@ class VaultModelRoundTripTest < Minitest::Test
     fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
   end
 
+  def test_vault_dek_rekeyed_round_trip
+    fixture = {
+      "object" => "event",
+      "id" => "stub",
+      "event" => "vault.dek.rekeyed",
+      "data" => {},
+      "created_at" => "stub",
+      "context" => {}
+    }
+    model = WorkOS::VaultDekRekeyed.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["id"], json[:id]
+    assert_equal fixture["created_at"], json[:created_at]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
+  def test_vault_dek_rekeyed_data_round_trip
+    fixture = {
+      "actor_id" => "stub",
+      "actor_source" => "stub",
+      "actor_name" => "stub",
+      "key_ids" => [],
+      "key_context" => {}
+    }
+    model = WorkOS::VaultDekRekeyedData.new(fixture.to_json)
+    json = model.to_h
+    assert_kind_of Hash, json
+    assert_equal fixture["actor_id"], json[:actor_id]
+    assert_equal fixture["actor_name"], json[:actor_name]
+    fixture.each_key { |k| assert json.key?(k.to_sym) || json.key?(k), "Expected to_h to include key #{k}" }
+  end
+
   def test_vault_kek_created_round_trip
     fixture = {
       "object" => "event",