@klarna/react-native-klarna-network-messaging 0.0.1 → 2.6.0

package/ios/Sources/view/KlarnaMessagingPlacementViewWrapper.mm

@@ -0,0 +1,183 @@
+#import <react/renderer/components/KlarnaNetworkMessagingSpec/ComponentDescriptors.h>
+#import <react/renderer/components/KlarnaNetworkMessagingSpec/EventEmitters.h>
+#import <react/renderer/components/KlarnaNetworkMessagingSpec/Props.h>
+#import <react/renderer/components/KlarnaNetworkMessagingSpec/RCTComponentViewHelpers.h>
+#import "KlarnaMessagingPlacementViewWrapper.h"
+#import "RCTFabricComponentsPlugins.h"
+
+// Framework form resolves under use_frameworks!; quoted form is the headermap fallback for static builds.
+#if __has_include(<react_native_klarna_network_messaging/react_native_klarna_network_messaging-Swift.h>)
+#import <react_native_klarna_network_messaging/react_native_klarna_network_messaging-Swift.h>
+#else
+#import "react_native_klarna_network_messaging-Swift.h"
+#endif
+
+using namespace facebook::react;
+
+@interface KlarnaMessagingPlacementViewWrapper () <RCTRNKlarnaMessagingPlacementViewViewProtocol, KlarnaMessagingHeightDelegate>
+
+@property (nonatomic, strong) UIView* placementView;
+@property (nonatomic, strong) KlarnaMessagingHeightObserver* heightObserver;
+
+@end
+
+@implementation KlarnaMessagingPlacementViewWrapper
+
+#pragma mark - Initialization
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+    self = [super initWithFrame:frame];
+    if (self) {
+        self.backgroundColor = [UIColor clearColor];
+        self.clipsToBounds = NO;
+        self.heightObserver = [[KlarnaMessagingHeightObserver alloc] initWithDelayIntervals:@[@0.5, @1.5, @3.0]];
+        self.heightObserver.delegate = self;
+        static const auto defaultProps = std::make_shared<const RNKlarnaMessagingPlacementViewProps>();
+        _props = defaultProps;
+    }
+    return self;
+}
+
+- (void)dealloc {
+    [self.heightObserver stopObserving];
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+    return concreteComponentDescriptorProvider<RNKlarnaMessagingPlacementViewComponentDescriptor>();
+}
+
+Class<RCTComponentViewProtocol> RNKlarnaMessagingPlacementViewCls(void)
+{
+    return KlarnaMessagingPlacementViewWrapper.class;
+}
+
+#pragma mark - Props Update
+
+/// Diffs all placement-related props against their previous values and triggers
+/// a full view recreation when any of them change. Props are compared before
+/// `[super updateProps:…]` stores the new snapshot.
+- (void)updateProps:(const facebook::react::Props::Shared &)props oldProps:(const facebook::react::Props::Shared &)oldProps {
+    const auto &oldViewProps = *std::static_pointer_cast<RNKlarnaMessagingPlacementViewProps const>(_props);
+    const auto &newViewProps = *std::static_pointer_cast<RNKlarnaMessagingPlacementViewProps const>(props);
+
+    BOOL needsRecreate = oldViewProps.instanceId != newViewProps.instanceId
+        || oldViewProps.placementType != newViewProps.placementType
+        || oldViewProps.theme != newViewProps.theme
+        || oldViewProps.amount != newViewProps.amount
+        || oldViewProps.currency != newViewProps.currency;
+
+    [super updateProps:props oldProps:oldProps];
+
+    if (needsRecreate) {
+        NSString *instanceId = [[NSString alloc] initWithUTF8String:newViewProps.instanceId.c_str()];
+        NSString *placementType = [[NSString alloc] initWithUTF8String:newViewProps.placementType.c_str()];
+        NSString *theme = [[NSString alloc] initWithUTF8String:newViewProps.theme.c_str()];
+        NSString *amount = [[NSString alloc] initWithUTF8String:newViewProps.amount.c_str()];
+        NSString *currency = [[NSString alloc] initWithUTF8String:newViewProps.currency.c_str()];
+
+        [self recreatePlacementViewWithInstanceId:instanceId
+                                    placementType:placementType
+                                            theme:theme
+                                           amount:amount
+                                         currency:currency];
+    }
+}
+
+#pragma mark - Placement View Management
+
+/// Tears down any existing SDK placement view and builds a fresh one from the
+/// latest props. Validates required fields (instanceId, currency, amount), resolves
+/// the Klarna instance from the core module, then creates and attaches the new
+/// view with an active height observer.
+- (void)recreatePlacementViewWithInstanceId:(NSString *)instanceId
+                              placementType:(NSString *)placementType
+                                      theme:(NSString *)theme
+                                     amount:(NSString *)amount
+                                   currency:(NSString *)currency {
+    if (!instanceId || instanceId.length == 0) {
+        return;
+    }
+    if (!currency || currency.length == 0) {
+        return;
+    }
+
+    NSNumber *parsedAmountNumber = [KlarnaMessagingPlacementViewHelper parseAmount:amount];
+    if (!parsedAmountNumber) {
+        return;
+    }
+
+    [self.heightObserver stopObserving];
+    [self.placementView removeFromSuperview];
+    self.placementView = nil;
+
+    id klarnaInstance = [KlarnaMessagingPlacementViewFactory resolveKlarnaWithInstanceId:instanceId];
+    if (!klarnaInstance) {
+        [self emitErrorWithName:@"NotInitialized"
+                        message:@"No Klarna instance found for instanceId. Call Klarna.initialize() first."];
+        return;
+    }
+
+    long long parsedAmount = parsedAmountNumber.longLongValue;
+    UIView *view = [KlarnaMessagingPlacementViewFactory
+                    createPlacementViewWithKlarna:klarnaInstance
+                    placementType:placementType ?: KlarnaMessagingPlacementViewFactory.defaultPlacementType
+                    theme:theme ?: @""
+                    amount:parsedAmount
+                    currency:currency];
+
+    if (!view) {
+        [self emitErrorWithName:@"CreateFailed"
+                        message:@"Failed to create KlarnaMessagingPlacementView."];
+        return;
+    }
+
+    self.placementView = view;
+    [KlarnaMessagingPlacementViewHelper addPlacementSubview:view to:self pinWidth:NO];
+    [self.heightObserver observe:view];
+}
+
+#pragma mark - Event Emission
+
+/// Emits an `onError` Fabric event carrying a `{name, message}` error payload.
+- (void)emitErrorWithName:(NSString *)name message:(NSString *)message {
+    if (_eventEmitter) {
+        auto emitter = std::dynamic_pointer_cast<const RNKlarnaMessagingPlacementViewEventEmitter>(_eventEmitter);
+        if (emitter) {
+            emitter->onError(RNKlarnaMessagingPlacementViewEventEmitter::OnError{
+                .error = {
+                    .name = std::string([name UTF8String]),
+                    .message = std::string([message UTF8String]),
+                }
+            });
+        }
+    }
+}
+
+#pragma mark - KlarnaMessagingHeightDelegate
+
+/// Called by `KlarnaMessagingHeightObserver` when the placement content height
+/// changes. Emits an `onResized` Fabric event so the JS side can adjust layout.
+- (void)placementViewDidUpdateHeight:(CGFloat)height {
+    if (_eventEmitter) {
+        auto emitter = std::dynamic_pointer_cast<const RNKlarnaMessagingPlacementViewEventEmitter>(_eventEmitter);
+        if (emitter) {
+            emitter->onResized(RNKlarnaMessagingPlacementViewEventEmitter::OnResized{
+                .height = std::string([[[NSNumber numberWithFloat:height] stringValue] UTF8String]),
+            });
+        }
+    }
+}
+
+#pragma mark - Layout
+
+- (void)layoutSubviews {
+    [super layoutSubviews];
+    if (self.placementView) {
+        [KlarnaMessagingPlacementViewFactory clearBackgrounds:self.placementView];
+    }
+    [self.heightObserver checkAndReportHeight];
+}
+
+@end

package/ios/Tests/KlarnaMessagingHeightObserverTests.swift

@@ -0,0 +1,204 @@
+import XCTest
+@testable import react_native_klarna_network_messaging
+
+class MockHeightDelegate: NSObject, KlarnaMessagingHeightDelegate {
+    var reportedHeights: [CGFloat] = []
+
+    func placementViewDidUpdateHeight(_ height: CGFloat) {
+        reportedHeights.append(height)
+    }
+}
+
+class KlarnaMessagingHeightObserverTests: XCTestCase {
+
+    var observer: KlarnaMessagingHeightObserver!
+    var delegate: MockHeightDelegate!
+
+    override func setUp() {
+        super.setUp()
+        delegate = MockHeightDelegate()
+        observer = KlarnaMessagingHeightObserver(delayIntervals: [])
+        observer.delegate = delegate
+    }
+
+    override func tearDown() {
+        observer.stopObserving()
+        observer = nil
+        delegate = nil
+        super.tearDown()
+    }
+
+    // MARK: - Basic Observation
+
+    func testCheckAndReportHeight_doesNothingWithoutObservedView() {
+        observer.checkAndReportHeight()
+        XCTAssertTrue(delegate.reportedHeights.isEmpty)
+    }
+
+    func testCheckAndReportHeight_reportsHeightForViewWithFrame() {
+        let container = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        let view = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 100))
+        container.addSubview(view)
+
+        observer.observe(view)
+        observer.checkAndReportHeight()
+
+        XCTAssertEqual(delegate.reportedHeights.count, 1)
+        XCTAssertEqual(delegate.reportedHeights.first, 100)
+    }
+
+    func testCheckAndReportHeight_doesNotReportZeroHeight() {
+        let view = UIView(frame: .zero)
+        observer.observe(view)
+        observer.checkAndReportHeight()
+
+        XCTAssertTrue(delegate.reportedHeights.isEmpty)
+    }
+
+    func testCheckAndReportHeight_doesNotReportSameHeightTwice() {
+        let container = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        let view = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 80))
+        container.addSubview(view)
+
+        observer.observe(view)
+        observer.checkAndReportHeight()
+        observer.checkAndReportHeight()
+
+        XCTAssertEqual(delegate.reportedHeights.count, 1)
+    }
+
+    func testCheckAndReportHeight_reportsNewHeightAfterChange() {
+        let container = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        let view = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 80))
+        container.addSubview(view)
+
+        observer.observe(view)
+        observer.checkAndReportHeight()
+
+        view.frame = CGRect(x: 0, y: 0, width: 320, height: 120)
+        observer.checkAndReportHeight()
+
+        XCTAssertEqual(delegate.reportedHeights.count, 2)
+        XCTAssertEqual(delegate.reportedHeights[0], 80)
+        XCTAssertEqual(delegate.reportedHeights[1], 120)
+    }
+
+    // MARK: - stopObserving
+
+    func testStopObserving_preventsSubsequentReports() {
+        let container = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        let view = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 100))
+        container.addSubview(view)
+
+        observer.observe(view)
+        observer.stopObserving()
+        observer.checkAndReportHeight()
+
+        XCTAssertTrue(delegate.reportedHeights.isEmpty)
+    }
+
+    func testStopObserving_canBeCalledMultipleTimes() {
+        let view = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 100))
+        observer.observe(view)
+        observer.stopObserving()
+        observer.stopObserving() // Should not crash
+    }
+
+    // Guards against the KVO crash "instance was deallocated while key value
+    // observers were still registered". The observer must hold the observed
+    // view strongly while observation is active, otherwise the view can die
+    // before stopObserving runs.
+    func testObservedView_isRetainedWhileObservationIsActive() {
+        weak var weakView: UIView?
+        autoreleasepool {
+            let view = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 100))
+            weakView = view
+            observer.observe(view)
+        }
+        XCTAssertNotNil(weakView, "observer must keep the observed view alive while observing")
+        observer.stopObserving()
+        XCTAssertNil(weakView, "observed view must be released after stopObserving")
+    }
+
+    // MARK: - Re-observe
+
+    func testObserve_resetsLastReportedHeight() {
+        let container = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        let view = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 100))
+        container.addSubview(view)
+
+        observer.observe(view)
+        observer.checkAndReportHeight()
+        XCTAssertEqual(delegate.reportedHeights.count, 1)
+
+        // Re-observe the same view — height should be reported again
+        observer.observe(view)
+        observer.checkAndReportHeight()
+        XCTAssertEqual(delegate.reportedHeights.count, 2)
+    }
+
+    // MARK: - Delayed Checks
+
+    func testDelayedChecks_fireAfterIntervals() {
+        let delayObserver = KlarnaMessagingHeightObserver(delayIntervals: [0.1])
+        delayObserver.delegate = delegate
+
+        let container = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        let view = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 50))
+        container.addSubview(view)
+
+        delayObserver.observe(view)
+
+        let expectation = expectation(description: "Delayed height check fires")
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 1.0)
+        XCTAssertFalse(delegate.reportedHeights.isEmpty)
+
+        delayObserver.stopObserving()
+    }
+
+    // MARK: - No Content (height 0 fallback)
+
+    func testReportsZeroHeight_whenAllDelaysFinishWithNoContent() {
+        let delayObserver = KlarnaMessagingHeightObserver(delayIntervals: [0.05, 0.1])
+        delayObserver.delegate = delegate
+
+        let view = UIView(frame: .zero)
+        delayObserver.observe(view)
+
+        let expectation = expectation(description: "All delayed checks finished")
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 1.0)
+        XCTAssertEqual(delegate.reportedHeights, [0])
+
+        delayObserver.stopObserving()
+    }
+
+    func testDoesNotReportZero_whenHeightIsPositive() {
+        let delayObserver = KlarnaMessagingHeightObserver(delayIntervals: [0.05, 0.1])
+        delayObserver.delegate = delegate
+
+        let container = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        let view = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 80))
+        container.addSubview(view)
+
+        delayObserver.observe(view)
+
+        let expectation = expectation(description: "All delayed checks finished")
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 1.0)
+        XCTAssertFalse(delegate.reportedHeights.isEmpty)
+        XCTAssertFalse(delegate.reportedHeights.contains(0))
+
+        delayObserver.stopObserving()
+    }
+}

package/ios/Tests/KlarnaMessagingPlacementViewFactoryTests.swift

@@ -0,0 +1,167 @@
+import XCTest
+import KlarnaCore
+import KlarnaNetworkMessaging
+@testable import react_native_klarna_network_messaging
+
+private let autoSize = PlacementType.autoSize.rawValue
+private let badge = PlacementType.badge.rawValue
+
+class KlarnaMessagingPlacementViewFactoryTests: XCTestCase {
+
+    // MARK: - parseTheme
+
+    func testParseTheme_lightMapsToLight() {
+        XCTAssertEqual(KlarnaMessagingPlacementViewFactory.parseTheme("light"), .light)
+    }
+
+    func testParseTheme_darkMapsToDark() {
+        XCTAssertEqual(KlarnaMessagingPlacementViewFactory.parseTheme("dark"), .dark)
+    }
+
+    func testParseTheme_automaticMapsToAutomatic() {
+        XCTAssertEqual(KlarnaMessagingPlacementViewFactory.parseTheme("automatic"), .automatic)
+    }
+
+    func testParseTheme_unknownReturnsNil() {
+        XCTAssertNil(KlarnaMessagingPlacementViewFactory.parseTheme("neon"))
+    }
+
+    func testParseTheme_emptyReturnsNil() {
+        XCTAssertNil(KlarnaMessagingPlacementViewFactory.parseTheme(""))
+    }
+
+    func testParseTheme_isCaseSensitive() {
+        XCTAssertNil(KlarnaMessagingPlacementViewFactory.parseTheme("LIGHT"))
+        XCTAssertNil(KlarnaMessagingPlacementViewFactory.parseTheme("Dark"))
+    }
+
+    // MARK: - makeConfiguration
+
+    func testMakeConfiguration_badgeReturnsBadgeVariant() {
+        let config = KlarnaMessagingPlacementViewFactory.makeConfiguration(
+            placementType: badge,
+            theme: .light,
+            amount: 1000,
+            currency: "USD"
+        )
+        if case .creditPromotionBadge = config {
+            // expected
+        } else {
+            XCTFail("Expected .creditPromotionBadge case, got \(config)")
+        }
+    }
+
+    func testMakeConfiguration_autoSizeReturnsAutoSizeVariant() {
+        let config = KlarnaMessagingPlacementViewFactory.makeConfiguration(
+            placementType: autoSize,
+            theme: .dark,
+            amount: 2000,
+            currency: "EUR"
+        )
+        if case .creditPromotionAutoSize = config {
+            // expected
+        } else {
+            XCTFail("Expected .creditPromotionAutoSize case, got \(config)")
+        }
+    }
+
+    func testMakeConfiguration_unknownDefaultsToAutoSize() {
+        let config = KlarnaMessagingPlacementViewFactory.makeConfiguration(
+            placementType: "SomethingElse",
+            theme: .automatic,
+            amount: 500,
+            currency: "SEK"
+        )
+        if case .creditPromotionAutoSize = config {
+            // expected
+        } else {
+            XCTFail("Expected .creditPromotionAutoSize fallback, got \(config)")
+        }
+    }
+
+    func testMakeConfiguration_emptyDefaultsToAutoSize() {
+        let config = KlarnaMessagingPlacementViewFactory.makeConfiguration(
+            placementType: "",
+            theme: .automatic,
+            amount: 0,
+            currency: "GBP"
+        )
+        if case .creditPromotionAutoSize = config {
+            // expected
+        } else {
+            XCTFail("Expected .creditPromotionAutoSize fallback for empty string, got \(config)")
+        }
+    }
+
+    func testMakeConfiguration_nilThemeFlowsThroughToConfiguration() {
+        // When theme is nil the factory must not synthesize a default; the
+        // configuration must carry nil so the native SDK applies its own.
+        let autoSizeConfig = KlarnaMessagingPlacementViewFactory.makeConfiguration(
+            placementType: autoSize,
+            theme: nil,
+            amount: 1000,
+            currency: "USD"
+        )
+        if case .creditPromotionAutoSize(_, _, let theme) = autoSizeConfig {
+            XCTAssertNil(theme)
+        } else {
+            XCTFail("Expected .creditPromotionAutoSize, got \(autoSizeConfig)")
+        }
+
+        let badgeConfig = KlarnaMessagingPlacementViewFactory.makeConfiguration(
+            placementType: badge,
+            theme: nil,
+            amount: 1000,
+            currency: "USD"
+        )
+        if case .creditPromotionBadge(_, _, let theme) = badgeConfig {
+            XCTAssertNil(theme)
+        } else {
+            XCTFail("Expected .creditPromotionBadge, got \(badgeConfig)")
+        }
+    }
+
+    func testMakeConfiguration_explicitThemeFlowsThroughToConfiguration() {
+        let config = KlarnaMessagingPlacementViewFactory.makeConfiguration(
+            placementType: autoSize,
+            theme: .dark,
+            amount: 1000,
+            currency: "USD"
+        )
+        if case .creditPromotionAutoSize(_, _, let theme) = config {
+            XCTAssertEqual(theme, .dark)
+        } else {
+            XCTFail("Expected .creditPromotionAutoSize, got \(config)")
+        }
+    }
+
+    func testMakeConfiguration_caseSensitiveOnBadge() {
+        // Only exact "CreditPromotionBadge" returns the badge variant.
+        let config = KlarnaMessagingPlacementViewFactory.makeConfiguration(
+            placementType: "creditpromotionbadge",
+            theme: .automatic,
+            amount: 100,
+            currency: "NOK"
+        )
+        if case .creditPromotionAutoSize = config {
+            // expected
+        } else {
+            XCTFail("Expected .creditPromotionAutoSize for lowercase input, got \(config)")
+        }
+    }
+
+    // MARK: - createPlacementView
+
+    func testCreatePlacementView_returnsNilForInvalidKlarnaObject() {
+        // Any non-Klarna object should cause the factory to return nil rather than crash.
+        let invalidKlarna = NSObject()
+        let view = KlarnaMessagingPlacementViewFactory.createPlacementView(
+            klarna: invalidKlarna,
+            placementType: autoSize,
+            theme: "automatic",
+            amount: 1000,
+            currency: "USD"
+        )
+        XCTAssertNil(view)
+    }
+}

package/ios/Tests/KlarnaMessagingPlacementViewHelperTests.swift

@@ -0,0 +1,118 @@
+import XCTest
+@testable import react_native_klarna_network_messaging
+
+class KlarnaMessagingPlacementViewHelperTests: XCTestCase {
+
+    // MARK: - parseAmount
+
+    func testParseAmount_returnsNilForNil() {
+        XCTAssertNil(KlarnaMessagingPlacementViewHelper.parseAmount(nil))
+    }
+
+    func testParseAmount_returnsNilForEmpty() {
+        XCTAssertNil(KlarnaMessagingPlacementViewHelper.parseAmount(""))
+    }
+
+    func testParseAmount_returnsNilForNonNumeric() {
+        XCTAssertNil(KlarnaMessagingPlacementViewHelper.parseAmount("abc"))
+    }
+
+    func testParseAmount_returnsNilForDecimal() {
+        XCTAssertNil(KlarnaMessagingPlacementViewHelper.parseAmount("12.5"))
+    }
+
+    func testParseAmount_returnsNilForOutOfRange() {
+        XCTAssertNil(KlarnaMessagingPlacementViewHelper.parseAmount("99999999999999999999"))
+    }
+
+    func testParseAmount_parsesValidInteger() {
+        XCTAssertEqual(KlarnaMessagingPlacementViewHelper.parseAmount("19900"), NSNumber(value: 19900))
+    }
+
+    func testParseAmount_parsesNegativeInteger() {
+        XCTAssertEqual(KlarnaMessagingPlacementViewHelper.parseAmount("-500"), NSNumber(value: -500))
+    }
+
+    // MARK: - calculateHeight
+
+    func testCalculateHeight_returnsZeroForEmptyView() {
+        let view = UIView(frame: .zero)
+        let height = KlarnaMessagingPlacementViewHelper.calculateHeight(for: view, containerWidth: 320)
+        XCTAssertEqual(height, 0)
+    }
+
+    func testCalculateHeight_returnsFrameHeight() {
+        let view = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 100))
+        let height = KlarnaMessagingPlacementViewHelper.calculateHeight(for: view, containerWidth: 320)
+        XCTAssertEqual(height, 100)
+    }
+
+    func testCalculateHeight_returnsSubviewMaxY() {
+        let view = UIView(frame: .zero)
+        let subview = UIView(frame: CGRect(x: 0, y: 10, width: 100, height: 50))
+        view.addSubview(subview)
+        let height = KlarnaMessagingPlacementViewHelper.calculateHeight(for: view, containerWidth: 320)
+        XCTAssertEqual(height, 60) // 10 + 50
+    }
+
+    func testCalculateHeight_usesScreenWidthWhenContainerWidthIsZero() {
+        let view = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 80))
+        let height = KlarnaMessagingPlacementViewHelper.calculateHeight(for: view, containerWidth: 0)
+        XCTAssertGreaterThanOrEqual(height, 0)
+    }
+
+    // MARK: - addPlacementSubview
+
+    func testAddPlacementSubview_addsSubview() {
+        let container = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        let placement = UIView()
+
+        KlarnaMessagingPlacementViewHelper.addPlacementSubview(placement, to: container, pinWidth: false)
+
+        XCTAssertEqual(container.subviews.count, 1)
+        XCTAssertTrue(container.subviews.contains(placement))
+    }
+
+    func testAddPlacementSubview_disablesAutoresizingMask() {
+        let container = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        let placement = UIView()
+
+        KlarnaMessagingPlacementViewHelper.addPlacementSubview(placement, to: container, pinWidth: false)
+
+        XCTAssertFalse(placement.translatesAutoresizingMaskIntoConstraints)
+    }
+
+    func testAddPlacementSubview_addsTopLeadingTrailingConstraints() {
+        let container = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        let placement = UIView()
+
+        KlarnaMessagingPlacementViewHelper.addPlacementSubview(placement, to: container, pinWidth: false)
+
+        // Should have at least top, leading, trailing constraints
+        let constraints = container.constraints.filter { constraint in
+            constraint.firstItem === placement || constraint.secondItem === placement
+        }
+        XCTAssertGreaterThanOrEqual(constraints.count, 3)
+    }
+
+    func testAddPlacementSubview_pinsWidthWhenRequested() {
+        let container = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 200))
+        let placement = UIView()
+
+        KlarnaMessagingPlacementViewHelper.addPlacementSubview(placement, to: container, pinWidth: true)
+
+        let widthConstraints = placement.constraints.filter { $0.firstAttribute == .width }
+        XCTAssertEqual(widthConstraints.count, 1)
+        XCTAssertEqual(widthConstraints.first?.constant, 320)
+    }
+
+    func testAddPlacementSubview_doesNotPinWidthWhenContainerHasZeroWidth() {
+        let container = UIView(frame: .zero)
+        let placement = UIView()
+
+        KlarnaMessagingPlacementViewHelper.addPlacementSubview(placement, to: container, pinWidth: true)
+
+        let widthConstraints = placement.constraints.filter { $0.firstAttribute == .width }
+        XCTAssertEqual(widthConstraints.count, 0)
+    }
+}