nirbarazida
/
promptfoo
mirror of https://github.com/promptfoo/promptfoo


  
1

	
2

	
3

	
4

	
5

	
6

	
7

	
8

	
9

	
10

	
11

	
12

	
13

	
14

	
15

	
16

	
17

	
18

	
19

	
20

	
21

	
22

	
23

	
24

	
25

	
26

	
27

	
28

	
29

	
30

	
31

	
32

	
33

	
34

	
35

	
36

	
37

	
38

	
39

	
40

	
41

	
42

	
43

	
44

	
45

	
46

	
47

	
48

	
49

	
50

	
51

	
52

	
53

	
54

	
55

	
56

	
57

	
58

	
59

	
60

	
61

	
62

	
63

	
64

	
65

	
66

	
67

	
68

	
69

	
70

	
71

	
72

	
73

	
74

	
75

	
76

	
77

	
78

	
79

	
80

	
81

	
82

	
83

	
84

	
85

	
86

	
87

	
88

	
89

	
90

	
91

	
92

	
93

	
94

	
95

	
96

	
97

	
98

	
99

	
100

	
101

	
102

	
103

	
104

	
105

	
106

	
107

	
108

	
            import { addHexEncoding } from '../../../src/redteam/strategies/hex';

import type { TestCase } from '../../../src/types';

describe('addHexEncoding', () => {
  it('should encode variable value as hex and append /Hex to metrics', () => {
    const testCases: TestCase[] = [
      {
        vars: {
          input: 'hello',
        },
        assert: [
          {
            type: 'contains',
            metric: 'accuracy',
          },
        ],
      },
    ];

    const result = addHexEncoding(testCases, 'input');

    expect(result[0].vars!.input).toBe('68 65 6C 6C 6F');
    expect(result[0].assert![0].metric).toBe('accuracy/Hex');
    expect(result[0].metadata).toEqual({
      strategyId: 'hex',
      originalText: 'hello',
    });
  });

  it('should handle empty string', () => {
    const testCases: TestCase[] = [
      {
        vars: {
          input: '',
        },
        assert: [
          {
            type: 'contains',
            metric: 'accuracy',
          },
        ],
      },
    ];

    const result = addHexEncoding(testCases, 'input');

    expect(result[0].vars!.input).toBe('');
    expect(result[0].assert![0].metric).toBe('accuracy/Hex');
  });

  it('should handle special characters', () => {
    const testCases: TestCase[] = [
      {
        vars: {
          input: '!@#$',
        },
        assert: [
          {
            type: 'contains',
            metric: 'accuracy',
          },
        ],
      },
    ];

    const result = addHexEncoding(testCases, 'input');

    expect(result[0].vars!.input).toBe('21 40 23 24');
    expect(result[0].assert![0].metric).toBe('accuracy/Hex');
  });

  it('should handle numbers', () => {
    const testCases: TestCase[] = [
      {
        vars: {
          input: 123,
        },
        assert: [
          {
            type: 'contains',
            metric: 'accuracy',
          },
        ],
      },
    ];

    const result = addHexEncoding(testCases, 'input');

    expect(result[0].vars!.input).toBe('31 32 33');
    expect(result[0].assert![0].metric).toBe('accuracy/Hex');
  });

  it('should handle test case without assertions', () => {
    const testCases: TestCase[] = [
      {
        vars: {
          input: 'test',
        },
      },
    ];

    const result = addHexEncoding(testCases, 'input');

    expect(result[0].vars!.input).toBe('74 65 73 74');
    expect(result[0].assert).toBeUndefined();
  });
});