From 90b2038ccf99b9f286c18446cbfc82e1dc3dfe16 Mon Sep 17 00:00:00 2001
From: tarunrajput <tarunrajput1337@gmail.com>
Date: Mon, 11 Sep 2023 23:26:38 +0530
Subject: [PATCH 1/4] feat: add toHaveAccessibilityValue matcher

---
 .../__tests__/to-have-accessibility-value.tsx | 149 ++++++++++++++++++
 src/matchers/extend-expect.d.ts               |   2 +
 src/matchers/extend-expect.ts                 |   2 +
 src/matchers/index.tsx                        |   1 +
 src/matchers/to-have-accessibility-value.tsx  |  38 +++++
 5 files changed, 192 insertions(+)
 create mode 100644 src/matchers/__tests__/to-have-accessibility-value.tsx
 create mode 100644 src/matchers/to-have-accessibility-value.tsx

diff --git a/src/matchers/__tests__/to-have-accessibility-value.tsx b/src/matchers/__tests__/to-have-accessibility-value.tsx
new file mode 100644
index 000000000..1f1b356db
--- /dev/null
+++ b/src/matchers/__tests__/to-have-accessibility-value.tsx
@@ -0,0 +1,149 @@
+import * as React from 'react';
+import { View } from 'react-native';
+import { render, screen } from '../..';
+import '../extend-expect';
+
+function renderViewsWithAccessibilityValue() {
+  return render(
+    <>
+      <View testID="min" accessibilityValue={{ min: 0 }} />
+      <View testID="max" accessibilityValue={{ max: 100 }} />
+      <View testID="now" accessibilityValue={{ now: 65 }} />
+      <View testID="min-max" accessibilityValue={{ min: 0, max: 100 }} />
+      <View
+        testID="min-max-now"
+        accessibilityValue={{ min: 0, max: 100, now: 65 }}
+      />
+      <View
+        testID="min-max-now-text"
+        accessibilityValue={{ text: 'test', min: 0, max: 100, now: 65 }}
+      />
+      <View
+        testID="text"
+        accessibilityValue={{ text: 'accessibility value' }}
+      />
+    </>
+  );
+}
+
+test('toHaveAccessibilityValue() on matching accessibility value', () => {
+  renderViewsWithAccessibilityValue();
+
+  const min = screen.getByTestId('min');
+  const max = screen.getByTestId('max');
+  const now = screen.getByTestId('now');
+  const text = screen.getByTestId('text');
+  const minMax = screen.getByTestId('min-max');
+  const minMaxNow = screen.getByTestId('min-max-now');
+  const minMaxNowText = screen.getByTestId('min-max-now-text');
+
+  expect(min).toHaveAccessibilityValue({ min: 0 });
+  expect(max).toHaveAccessibilityValue({ max: 100 });
+  expect(now).toHaveAccessibilityValue({ now: 65 });
+  expect(minMax).toHaveAccessibilityValue({ min: 0, max: 100 });
+  expect(minMaxNowText).toHaveAccessibilityValue({
+    min: 0,
+    max: 100,
+    now: 65,
+    text: 'test',
+  });
+  expect(minMaxNow).toHaveAccessibilityValue({ min: 0, max: 100, now: 65 });
+  expect(text).toHaveAccessibilityValue({ text: 'accessibility value' });
+  expect(text).toHaveAccessibilityValue({ text: /accessibility/i });
+
+  expect(() => expect(min).not.toHaveAccessibilityValue({ min: 0 }))
+    .toThrowErrorMatchingInlineSnapshot(`
+  "expect(element).not.toHaveAccessibilityValue({"min": 0})
+
+  Expected the element not to have accessibility value:
+    {"min": 0}
+  Received element with accessibility value:
+    {"max": undefined, "min": 0, "now": undefined, "text": undefined}"
+  `);
+
+  expect(() => expect(text).toHaveAccessibilityValue({ text: 'value' }))
+    .toThrowErrorMatchingInlineSnapshot(`
+  "expect(element).toHaveAccessibilityValue({"text": "value"})
+
+  Expected the element to have accessibility value:
+    {"text": "value"}
+  Received element with accessibility value:
+    {"max": undefined, "min": undefined, "now": undefined, "text": "accessibility value"}"
+  `);
+
+  expect(() => expect(text).toHaveAccessibilityValue({ text: /test/i }))
+    .toThrowErrorMatchingInlineSnapshot(`
+  "expect(element).toHaveAccessibilityValue({"text": /test/i})
+
+  Expected the element to have accessibility value:
+    {"text": /test/i}
+  Received element with accessibility value:
+    {"max": undefined, "min": undefined, "now": undefined, "text": "accessibility value"}"
+  `);
+});
+
+test('toHaveAccessibilityValue() on non-matching accessibility value', () => {
+  renderViewsWithAccessibilityValue();
+
+  const min = screen.getByTestId('min');
+  const max = screen.getByTestId('max');
+  const now = screen.getByTestId('now');
+  const text = screen.getByTestId('text');
+  const minMax = screen.getByTestId('min-max');
+  const minMaxNow = screen.getByTestId('min-max-now');
+  const minMaxNowText = screen.getByTestId('min-max-now-text');
+
+  expect(min).not.toHaveAccessibilityValue({ min: 100 });
+  expect(max).not.toHaveAccessibilityValue({ max: 0 });
+  expect(now).not.toHaveAccessibilityValue({ now: 0 });
+  expect(text).not.toHaveAccessibilityValue({ text: 'accessibility' });
+  expect(minMax).not.toHaveAccessibilityValue({ min: 100, max: 0 });
+  expect(minMaxNow).not.toHaveAccessibilityValue({ min: 100, max: 0, now: 0 });
+  expect(minMaxNowText).not.toHaveAccessibilityValue({
+    min: 100,
+    max: 0,
+    now: 0,
+    text: 'accessibility',
+  });
+
+  expect(() => expect(min).toHaveAccessibilityValue({ min: 100 }))
+    .toThrowErrorMatchingInlineSnapshot(`
+  "expect(element).toHaveAccessibilityValue({"min": 100})
+
+  Expected the element to have accessibility value:
+    {"min": 100}
+  Received element with accessibility value:
+    {"max": undefined, "min": 0, "now": undefined, "text": undefined}"
+  `);
+});
+
+test('toHaveAccessibilityValue() when no accessibilityValue prop is provided', () => {
+  render(<View testID="view" />);
+
+  const view = screen.getByTestId('view');
+
+  expect(() => expect(view).toHaveAccessibilityValue({ min: 0 }))
+    .toThrowErrorMatchingInlineSnapshot(`
+  "expect(element).toHaveAccessibilityValue({"min": 0})
+
+  Expected the element to have accessibility value:
+    {"min": 0}
+  Received element with accessibility value:
+    undefined"
+  `);
+});
+
+test('toHaveAccessibilityValue() on partially matching accessibility value', () => {
+  renderViewsWithAccessibilityValue();
+
+  const minMax = screen.getByTestId('min-max');
+  const minMaxNow = screen.getByTestId('min-max-now');
+  const minMaxNowText = screen.getByTestId('min-max-now-text');
+
+  expect(minMax).toHaveAccessibilityValue({ min: 0 });
+  expect(minMax).toHaveAccessibilityValue({ max: 100 });
+  expect(minMaxNow).toHaveAccessibilityValue({ now: 65 });
+  expect(minMaxNow).toHaveAccessibilityValue({ min: 0, max: 100 });
+  expect(minMaxNowText).toHaveAccessibilityValue({ text: 'test' });
+  expect(minMaxNowText).toHaveAccessibilityValue({ text: /te/i });
+});
diff --git a/src/matchers/extend-expect.d.ts b/src/matchers/extend-expect.d.ts
index dd8bfa173..2cee509c3 100644
--- a/src/matchers/extend-expect.d.ts
+++ b/src/matchers/extend-expect.d.ts
@@ -1,6 +1,7 @@
 import type { StyleProp } from 'react-native';
 import type { ReactTestInstance } from 'react-test-renderer';
 import type { TextMatch, TextMatchOptions } from '../matches';
+import type { AccessibilityValueMatcher } from '../helpers/matchers/accessibilityValue';
 import type { Style } from './to-have-style';
 
 export interface JestNativeMatchers<R> {
@@ -20,6 +21,7 @@ export interface JestNativeMatchers<R> {
   toHaveProp(name: string, expectedValue?: unknown): R;
   toHaveStyle(style: StyleProp<Style>): R;
   toHaveTextContent(expectedText: TextMatch, options?: TextMatchOptions): R;
+  toHaveAccessibilityValue(expectedValue: AccessibilityValueMatcher): R;
 }
 
 // Implicit Jest global `expect`.
diff --git a/src/matchers/extend-expect.ts b/src/matchers/extend-expect.ts
index c262f3d1c..0ac009c09 100644
--- a/src/matchers/extend-expect.ts
+++ b/src/matchers/extend-expect.ts
@@ -15,6 +15,7 @@ import { toHaveDisplayValue } from './to-have-display-value';
 import { toHaveProp } from './to-have-prop';
 import { toHaveStyle } from './to-have-style';
 import { toHaveTextContent } from './to-have-text-content';
+import { toHaveAccessibilityValue } from './to-have-accessibility-value';
 
 expect.extend({
   toBeOnTheScreen,
@@ -33,4 +34,5 @@ expect.extend({
   toHaveProp,
   toHaveStyle,
   toHaveTextContent,
+  toHaveAccessibilityValue,
 });
diff --git a/src/matchers/index.tsx b/src/matchers/index.tsx
index 66a4a0942..2138fabce 100644
--- a/src/matchers/index.tsx
+++ b/src/matchers/index.tsx
@@ -9,6 +9,7 @@ export { toBePartiallyChecked } from './to-be-partially-checked';
 export { toBeSelected } from './to-be-selected';
 export { toBeVisible } from './to-be-visible';
 export { toContainElement } from './to-contain-element';
+export { toHaveAccessibilityValue } from './to-have-accessibility-value';
 export { toHaveDisplayValue } from './to-have-display-value';
 export { toHaveProp } from './to-have-prop';
 export { toHaveStyle } from './to-have-style';
diff --git a/src/matchers/to-have-accessibility-value.tsx b/src/matchers/to-have-accessibility-value.tsx
new file mode 100644
index 000000000..0b5337d92
--- /dev/null
+++ b/src/matchers/to-have-accessibility-value.tsx
@@ -0,0 +1,38 @@
+import type { ReactTestInstance } from 'react-test-renderer';
+import { matcherHint, stringify } from 'jest-matcher-utils';
+import { getAccessibilityValue } from '../helpers/accessiblity';
+import {
+  AccessibilityValueMatcher,
+  matchAccessibilityValue,
+} from '../helpers/matchers/accessibilityValue';
+import { checkHostElement, formatMessage } from './utils';
+
+export function toHaveAccessibilityValue(
+  this: jest.MatcherContext,
+  element: ReactTestInstance,
+  expectedValue: AccessibilityValueMatcher
+) {
+  checkHostElement(element, toHaveAccessibilityValue, this);
+
+  const value = getAccessibilityValue(element);
+
+  return {
+    pass: matchAccessibilityValue(element, expectedValue),
+    message: () => {
+      const matcher = matcherHint(
+        `${this.isNot ? '.not' : ''}.toHaveAccessibilityValue`,
+        'element',
+        stringify(expectedValue)
+      );
+      return formatMessage(
+        matcher,
+        `Expected the element ${
+          this.isNot ? 'not to' : 'to'
+        } have accessibility value`,
+        stringify(expectedValue),
+        'Received element with accessibility value',
+        stringify(value)
+      );
+    },
+  };
+}

From ebcbab5a90a001094eccc07bb8523dc3bf146578 Mon Sep 17 00:00:00 2001
From: Maciej Jastrzebski <mdjastrzebski@gmail.com>
Date: Mon, 23 Oct 2023 18:28:21 +0200
Subject: [PATCH 2/4] refactor: clenup

---
 ...ibility-value.tsx => to-have-accessibility-value.test.tsx} | 0
 src/matchers/extend-expect.d.ts                               | 2 +-
 src/matchers/extend-expect.ts                                 | 4 ++--
 src/matchers/{index.tsx => index.ts}                          | 0
 src/matchers/to-have-accessibility-value.tsx                  | 4 ++--
 5 files changed, 5 insertions(+), 5 deletions(-)
 rename src/matchers/__tests__/{to-have-accessibility-value.tsx => to-have-accessibility-value.test.tsx} (100%)
 rename src/matchers/{index.tsx => index.ts} (100%)

diff --git a/src/matchers/__tests__/to-have-accessibility-value.tsx b/src/matchers/__tests__/to-have-accessibility-value.test.tsx
similarity index 100%
rename from src/matchers/__tests__/to-have-accessibility-value.tsx
rename to src/matchers/__tests__/to-have-accessibility-value.test.tsx
diff --git a/src/matchers/extend-expect.d.ts b/src/matchers/extend-expect.d.ts
index 2cee509c3..1d8fccf23 100644
--- a/src/matchers/extend-expect.d.ts
+++ b/src/matchers/extend-expect.d.ts
@@ -17,11 +17,11 @@ export interface JestNativeMatchers<R> {
   toBeSelected(): R;
   toBeVisible(): R;
   toContainElement(element: ReactTestInstance | null): R;
+  toHaveAccessibilityValue(expectedValue: AccessibilityValueMatcher): R;
   toHaveDisplayValue(expectedValue: TextMatch, options?: TextMatchOptions): R;
   toHaveProp(name: string, expectedValue?: unknown): R;
   toHaveStyle(style: StyleProp<Style>): R;
   toHaveTextContent(expectedText: TextMatch, options?: TextMatchOptions): R;
-  toHaveAccessibilityValue(expectedValue: AccessibilityValueMatcher): R;
 }
 
 // Implicit Jest global `expect`.
diff --git a/src/matchers/extend-expect.ts b/src/matchers/extend-expect.ts
index 0ac009c09..983b83124 100644
--- a/src/matchers/extend-expect.ts
+++ b/src/matchers/extend-expect.ts
@@ -11,11 +11,11 @@ import { toBePartiallyChecked } from './to-be-partially-checked';
 import { toBeSelected } from './to-be-selected';
 import { toBeVisible } from './to-be-visible';
 import { toContainElement } from './to-contain-element';
+import { toHaveAccessibilityValue } from './to-have-accessibility-value';
 import { toHaveDisplayValue } from './to-have-display-value';
 import { toHaveProp } from './to-have-prop';
 import { toHaveStyle } from './to-have-style';
 import { toHaveTextContent } from './to-have-text-content';
-import { toHaveAccessibilityValue } from './to-have-accessibility-value';
 
 expect.extend({
   toBeOnTheScreen,
@@ -30,9 +30,9 @@ expect.extend({
   toBeSelected,
   toBeVisible,
   toContainElement,
+  toHaveAccessibilityValue,
   toHaveDisplayValue,
   toHaveProp,
   toHaveStyle,
   toHaveTextContent,
-  toHaveAccessibilityValue,
 });
diff --git a/src/matchers/index.tsx b/src/matchers/index.ts
similarity index 100%
rename from src/matchers/index.tsx
rename to src/matchers/index.ts
diff --git a/src/matchers/to-have-accessibility-value.tsx b/src/matchers/to-have-accessibility-value.tsx
index 0b5337d92..a5b8b28a6 100644
--- a/src/matchers/to-have-accessibility-value.tsx
+++ b/src/matchers/to-have-accessibility-value.tsx
@@ -14,7 +14,7 @@ export function toHaveAccessibilityValue(
 ) {
   checkHostElement(element, toHaveAccessibilityValue, this);
 
-  const value = getAccessibilityValue(element);
+  const receivedValue = getAccessibilityValue(element);
 
   return {
     pass: matchAccessibilityValue(element, expectedValue),
@@ -31,7 +31,7 @@ export function toHaveAccessibilityValue(
         } have accessibility value`,
         stringify(expectedValue),
         'Received element with accessibility value',
-        stringify(value)
+        stringify(receivedValue)
       );
     },
   };

From 370858d018846f440e7479f2cf3c695584bcdd05 Mon Sep 17 00:00:00 2001
From: Maciej Jastrzebski <mdjastrzebski@gmail.com>
Date: Wed, 25 Oct 2023 12:32:52 +0200
Subject: [PATCH 3/4] refactor: clean up tests

---
 src/helpers/format-default.ts                 |  22 +-
 src/helpers/object.ts                         |  21 ++
 .../to-have-accessibility-value.test.tsx      | 279 ++++++++++--------
 src/matchers/to-have-accessibility-value.tsx  |   3 +-
 4 files changed, 172 insertions(+), 153 deletions(-)

diff --git a/src/helpers/format-default.ts b/src/helpers/format-default.ts
index 717bed9ec..9077ca2df 100644
--- a/src/helpers/format-default.ts
+++ b/src/helpers/format-default.ts
@@ -1,4 +1,5 @@
 import { StyleSheet, ViewStyle } from 'react-native';
+import { removeUndefinedKeys } from './object';
 
 const propsToDisplay = [
   'accessible',
@@ -64,27 +65,6 @@ export function defaultMapProps(
   return result;
 }
 
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function removeUndefinedKeys(prop: unknown) {
-  if (!isObject(prop)) {
-    return prop;
-  }
-
-  let hasKeys = false;
-  const result: Record<string, unknown> = {};
-  Object.entries(prop).forEach(([key, value]) => {
-    if (value !== undefined) {
-      result[key] = value;
-      hasKeys = true;
-    }
-  });
-
-  return hasKeys ? result : undefined;
-}
-
 function extractStyle(style: ViewStyle | undefined) {
   if (style == null) {
     return undefined;
diff --git a/src/helpers/object.ts b/src/helpers/object.ts
index afb17b01e..1e407ef7e 100644
--- a/src/helpers/object.ts
+++ b/src/helpers/object.ts
@@ -8,3 +8,24 @@ export function pick<T extends {}>(object: T, keys: (keyof T)[]): Partial<T> {
 
   return result;
 }
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function removeUndefinedKeys(prop: unknown) {
+  if (!isObject(prop)) {
+    return prop;
+  }
+
+  let hasKeys = false;
+  const result: Record<string, unknown> = {};
+  Object.entries(prop).forEach(([key, value]) => {
+    if (value !== undefined) {
+      result[key] = value;
+      hasKeys = true;
+    }
+  });
+
+  return hasKeys ? result : undefined;
+}
diff --git a/src/matchers/__tests__/to-have-accessibility-value.test.tsx b/src/matchers/__tests__/to-have-accessibility-value.test.tsx
index 1f1b356db..ca4a156a1 100644
--- a/src/matchers/__tests__/to-have-accessibility-value.test.tsx
+++ b/src/matchers/__tests__/to-have-accessibility-value.test.tsx
@@ -3,147 +3,164 @@ import { View } from 'react-native';
 import { render, screen } from '../..';
 import '../extend-expect';
 
-function renderViewsWithAccessibilityValue() {
-  return render(
-    <>
-      <View testID="min" accessibilityValue={{ min: 0 }} />
-      <View testID="max" accessibilityValue={{ max: 100 }} />
-      <View testID="now" accessibilityValue={{ now: 65 }} />
-      <View testID="min-max" accessibilityValue={{ min: 0, max: 100 }} />
-      <View
-        testID="min-max-now"
-        accessibilityValue={{ min: 0, max: 100, now: 65 }}
-      />
-      <View
-        testID="min-max-now-text"
-        accessibilityValue={{ text: 'test', min: 0, max: 100, now: 65 }}
-      />
-      <View
-        testID="text"
-        accessibilityValue={{ text: 'accessibility value' }}
-      />
-    </>
-  );
-}
-
-test('toHaveAccessibilityValue() on matching accessibility value', () => {
-  renderViewsWithAccessibilityValue();
-
-  const min = screen.getByTestId('min');
-  const max = screen.getByTestId('max');
-  const now = screen.getByTestId('now');
-  const text = screen.getByTestId('text');
-  const minMax = screen.getByTestId('min-max');
-  const minMaxNow = screen.getByTestId('min-max-now');
-  const minMaxNowText = screen.getByTestId('min-max-now-text');
-
-  expect(min).toHaveAccessibilityValue({ min: 0 });
-  expect(max).toHaveAccessibilityValue({ max: 100 });
-  expect(now).toHaveAccessibilityValue({ now: 65 });
-  expect(minMax).toHaveAccessibilityValue({ min: 0, max: 100 });
-  expect(minMaxNowText).toHaveAccessibilityValue({
-    min: 0,
-    max: 100,
-    now: 65,
-    text: 'test',
+describe('toHaveAccessibilityValue', () => {
+  it('supports "accessibilityValue.min"', () => {
+    render(<View accessibilityValue={{ min: 0 }} />);
+    expect(screen.root).toHaveAccessibilityValue({ min: 0 });
+    expect(screen.root).not.toHaveAccessibilityValue({ min: 1 });
   });
-  expect(minMaxNow).toHaveAccessibilityValue({ min: 0, max: 100, now: 65 });
-  expect(text).toHaveAccessibilityValue({ text: 'accessibility value' });
-  expect(text).toHaveAccessibilityValue({ text: /accessibility/i });
-
-  expect(() => expect(min).not.toHaveAccessibilityValue({ min: 0 }))
-    .toThrowErrorMatchingInlineSnapshot(`
-  "expect(element).not.toHaveAccessibilityValue({"min": 0})
-
-  Expected the element not to have accessibility value:
-    {"min": 0}
-  Received element with accessibility value:
-    {"max": undefined, "min": 0, "now": undefined, "text": undefined}"
-  `);
-
-  expect(() => expect(text).toHaveAccessibilityValue({ text: 'value' }))
-    .toThrowErrorMatchingInlineSnapshot(`
-  "expect(element).toHaveAccessibilityValue({"text": "value"})
-
-  Expected the element to have accessibility value:
-    {"text": "value"}
-  Received element with accessibility value:
-    {"max": undefined, "min": undefined, "now": undefined, "text": "accessibility value"}"
-  `);
-
-  expect(() => expect(text).toHaveAccessibilityValue({ text: /test/i }))
-    .toThrowErrorMatchingInlineSnapshot(`
-  "expect(element).toHaveAccessibilityValue({"text": /test/i})
-
-  Expected the element to have accessibility value:
-    {"text": /test/i}
-  Received element with accessibility value:
-    {"max": undefined, "min": undefined, "now": undefined, "text": "accessibility value"}"
-  `);
-});
 
-test('toHaveAccessibilityValue() on non-matching accessibility value', () => {
-  renderViewsWithAccessibilityValue();
-
-  const min = screen.getByTestId('min');
-  const max = screen.getByTestId('max');
-  const now = screen.getByTestId('now');
-  const text = screen.getByTestId('text');
-  const minMax = screen.getByTestId('min-max');
-  const minMaxNow = screen.getByTestId('min-max-now');
-  const minMaxNowText = screen.getByTestId('min-max-now-text');
-
-  expect(min).not.toHaveAccessibilityValue({ min: 100 });
-  expect(max).not.toHaveAccessibilityValue({ max: 0 });
-  expect(now).not.toHaveAccessibilityValue({ now: 0 });
-  expect(text).not.toHaveAccessibilityValue({ text: 'accessibility' });
-  expect(minMax).not.toHaveAccessibilityValue({ min: 100, max: 0 });
-  expect(minMaxNow).not.toHaveAccessibilityValue({ min: 100, max: 0, now: 0 });
-  expect(minMaxNowText).not.toHaveAccessibilityValue({
-    min: 100,
-    max: 0,
-    now: 0,
-    text: 'accessibility',
+  it('supports "accessibilityValue.max"', () => {
+    render(<View accessibilityValue={{ max: 100 }} />);
+    expect(screen.root).toHaveAccessibilityValue({ max: 100 });
+    expect(screen.root).not.toHaveAccessibilityValue({ max: 99 });
   });
 
-  expect(() => expect(min).toHaveAccessibilityValue({ min: 100 }))
-    .toThrowErrorMatchingInlineSnapshot(`
-  "expect(element).toHaveAccessibilityValue({"min": 100})
+  it('supports "accessibilityValue.now"', () => {
+    render(<View accessibilityValue={{ now: 33 }} />);
+    expect(screen.root).toHaveAccessibilityValue({ now: 33 });
+    expect(screen.root).not.toHaveAccessibilityValue({ now: 34 });
+  });
 
-  Expected the element to have accessibility value:
-    {"min": 100}
-  Received element with accessibility value:
-    {"max": undefined, "min": 0, "now": undefined, "text": undefined}"
-  `);
-});
+  it('supports "accessibilityValue.text"', () => {
+    render(<View testID="view" accessibilityValue={{ text: 'Hello' }} />);
+    expect(screen.root).toHaveAccessibilityValue({ text: 'Hello' });
+    expect(screen.root).toHaveAccessibilityValue({ text: /He/ });
+    expect(screen.root).not.toHaveAccessibilityValue({ text: 'Hi' });
+    expect(screen.root).not.toHaveAccessibilityValue({ text: /Hi/ });
+  });
 
-test('toHaveAccessibilityValue() when no accessibilityValue prop is provided', () => {
-  render(<View testID="view" />);
+  it('supports "aria-valuemin"', () => {
+    render(<View testID="view" aria-valuemin={0} />);
+    expect(screen.root).toHaveAccessibilityValue({ min: 0 });
+    expect(screen.root).not.toHaveAccessibilityValue({ min: 1 });
+  });
 
-  const view = screen.getByTestId('view');
+  it('supports "aria-valuemax"', () => {
+    render(<View testID="view" aria-valuemax={100} />);
+    expect(screen.root).toHaveAccessibilityValue({ max: 100 });
+    expect(screen.root).not.toHaveAccessibilityValue({ max: 99 });
+  });
 
-  expect(() => expect(view).toHaveAccessibilityValue({ min: 0 }))
-    .toThrowErrorMatchingInlineSnapshot(`
-  "expect(element).toHaveAccessibilityValue({"min": 0})
+  it('supports "aria-valuenow"', () => {
+    render(<View testID="view" aria-valuenow={33} />);
+    expect(screen.root).toHaveAccessibilityValue({ now: 33 });
+    expect(screen.root).not.toHaveAccessibilityValue({ now: 34 });
+  });
 
-  Expected the element to have accessibility value:
-    {"min": 0}
-  Received element with accessibility value:
-    undefined"
-  `);
-});
+  it('supports "aria-valuetext"', () => {
+    render(<View testID="view" aria-valuetext="Hello" />);
+    expect(screen.root).toHaveAccessibilityValue({ text: 'Hello' });
+    expect(screen.root).toHaveAccessibilityValue({ text: /He/ });
+    expect(screen.root).not.toHaveAccessibilityValue({ text: 'Hi' });
+    expect(screen.root).not.toHaveAccessibilityValue({ text: /Hi/ });
+  });
 
-test('toHaveAccessibilityValue() on partially matching accessibility value', () => {
-  renderViewsWithAccessibilityValue();
+  it('supports multi-argument matching', () => {
+    render(
+      <View accessibilityValue={{ min: 1, max: 10, now: 5, text: '5/10' }} />
+    );
+
+    expect(screen.root).toHaveAccessibilityValue({ now: 5 });
+    expect(screen.root).toHaveAccessibilityValue({ now: 5, min: 1 });
+    expect(screen.root).toHaveAccessibilityValue({ now: 5, max: 10 });
+    expect(screen.root).toHaveAccessibilityValue({ now: 5, min: 1, max: 10 });
+    expect(screen.root).toHaveAccessibilityValue({ text: '5/10' });
+    expect(screen.root).toHaveAccessibilityValue({ now: 5, text: '5/10' });
+    expect(screen.root).toHaveAccessibilityValue({
+      now: 5,
+      min: 1,
+      max: 10,
+      text: '5/10',
+    });
+
+    expect(screen.root).not.toHaveAccessibilityValue({ now: 6 });
+    expect(screen.root).not.toHaveAccessibilityValue({ now: 5, min: 0 });
+    expect(screen.root).not.toHaveAccessibilityValue({ now: 5, max: 9 });
+    expect(screen.root).not.toHaveAccessibilityValue({
+      now: 5,
+      min: 1,
+      max: 10,
+      text: '5 of 10',
+    });
+  });
+
+  it('gives precedence to ARIA values', () => {
+    render(
+      <View
+        testID="view"
+        aria-valuemin={0}
+        aria-valuemax={100}
+        aria-valuenow={33}
+        aria-valuetext="Hello"
+        accessibilityValue={{ min: 10, max: 90, now: 30, text: 'Hi' }}
+      />
+    );
 
-  const minMax = screen.getByTestId('min-max');
-  const minMaxNow = screen.getByTestId('min-max-now');
-  const minMaxNowText = screen.getByTestId('min-max-now-text');
+    expect(screen.root).toHaveAccessibilityValue({ min: 0 });
+    expect(screen.root).toHaveAccessibilityValue({ max: 100 });
+    expect(screen.root).toHaveAccessibilityValue({ now: 33 });
+    expect(screen.root).toHaveAccessibilityValue({ text: 'Hello' });
 
-  expect(minMax).toHaveAccessibilityValue({ min: 0 });
-  expect(minMax).toHaveAccessibilityValue({ max: 100 });
-  expect(minMaxNow).toHaveAccessibilityValue({ now: 65 });
-  expect(minMaxNow).toHaveAccessibilityValue({ min: 0, max: 100 });
-  expect(minMaxNowText).toHaveAccessibilityValue({ text: 'test' });
-  expect(minMaxNowText).toHaveAccessibilityValue({ text: /te/i });
+    expect(screen.root).not.toHaveAccessibilityValue({ min: 10 });
+    expect(screen.root).not.toHaveAccessibilityValue({ max: 90 });
+    expect(screen.root).not.toHaveAccessibilityValue({ now: 30 });
+    expect(screen.root).not.toHaveAccessibilityValue({ text: 'Hi' });
+  });
+
+  it('shows errors in expected format', () => {
+    render(
+      <View
+        testID="view"
+        aria-valuemin={0}
+        aria-valuemax={100}
+        aria-valuenow={33}
+        aria-valuetext="Hello"
+      />
+    );
+
+    expect(() => expect(screen.root).toHaveAccessibilityValue({ min: 10 }))
+      .toThrowErrorMatchingInlineSnapshot(`
+      "expect(element).toHaveAccessibilityValue({"min": 10})
+
+      Expected the element to have accessibility value:
+        {"min": 10}
+      Received element with accessibility value:
+        {"max": 100, "min": 0, "now": 33, "text": "Hello"}"
+    `);
+
+    expect(() => expect(screen.root).not.toHaveAccessibilityValue({ min: 0 }))
+      .toThrowErrorMatchingInlineSnapshot(`
+      "expect(element).not.toHaveAccessibilityValue({"min": 0})
+
+      Expected the element not to have accessibility value:
+        {"min": 0}
+      Received element with accessibility value:
+        {"max": 100, "min": 0, "now": 33, "text": "Hello"}"
+    `);
+  });
+
+  it('shows errors in expected format with partial value', () => {
+    render(<View testID="view" aria-valuenow={33} aria-valuetext="Hello" />);
+
+    expect(() => expect(screen.root).toHaveAccessibilityValue({ min: 30 }))
+      .toThrowErrorMatchingInlineSnapshot(`
+      "expect(element).toHaveAccessibilityValue({"min": 30})
+
+      Expected the element to have accessibility value:
+        {"min": 30}
+      Received element with accessibility value:
+        {"now": 33, "text": "Hello"}"
+    `);
+
+    expect(() => expect(screen.root).not.toHaveAccessibilityValue({ now: 33 }))
+      .toThrowErrorMatchingInlineSnapshot(`
+      "expect(element).not.toHaveAccessibilityValue({"now": 33})
+
+      Expected the element not to have accessibility value:
+        {"now": 33}
+      Received element with accessibility value:
+        {"now": 33, "text": "Hello"}"
+    `);
+  });
 });
diff --git a/src/matchers/to-have-accessibility-value.tsx b/src/matchers/to-have-accessibility-value.tsx
index a5b8b28a6..a6ea49a12 100644
--- a/src/matchers/to-have-accessibility-value.tsx
+++ b/src/matchers/to-have-accessibility-value.tsx
@@ -5,6 +5,7 @@ import {
   AccessibilityValueMatcher,
   matchAccessibilityValue,
 } from '../helpers/matchers/accessibilityValue';
+import { removeUndefinedKeys } from '../helpers/object';
 import { checkHostElement, formatMessage } from './utils';
 
 export function toHaveAccessibilityValue(
@@ -31,7 +32,7 @@ export function toHaveAccessibilityValue(
         } have accessibility value`,
         stringify(expectedValue),
         'Received element with accessibility value',
-        stringify(receivedValue)
+        stringify(removeUndefinedKeys(receivedValue))
       );
     },
   };

From 6cecf2b3f0d0ae5516241bc730cf155d82d93acc Mon Sep 17 00:00:00 2001
From: Maciej Jastrzebski <mdjastrzebski@gmail.com>
Date: Wed, 25 Oct 2023 13:31:44 +0200
Subject: [PATCH 4/4] refactor: self review

---
 src/helpers/object.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/helpers/object.ts b/src/helpers/object.ts
index 1e407ef7e..50106a741 100644
--- a/src/helpers/object.ts
+++ b/src/helpers/object.ts
@@ -10,7 +10,7 @@ export function pick<T extends {}>(object: T, keys: (keyof T)[]): Partial<T> {
 }
 
 function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
 export function removeUndefinedKeys(prop: unknown) {