\r\n
1542 | if ((false !== $response = $this->_query("set $real_key $flags $expiration $bytes\r\n$value", $server_key))
1543 | &&
1544 | // Valid response.
1545 | isset(self::_STORE_SIGNALS[$response])
1546 | ) {
1547 | return $this->_return(self::_STORE_SIGNALS[$response] === self::RES_SUCCESS,
1548 | self::_STORE_SIGNALS[$response]);
1549 | }
1550 |
1551 | return $this->_return(false, self::RES_FAILURE, __METHOD__ . ' failed.');
1552 | }
1553 |
1554 | /**
1555 | * (PECL memcached >= 0.1.0)
1556 | * Store multiple items
1557 | *
1558 | * @link http://php.net/manual/en/memcached.setmulti.php
1559 | * @param array $items An array of key/value pairs to store on the server.
1560 | * @param int $expiration [optional] The expiration time, defaults to 0. See Expiration Times for more info.
1561 | * @return bool TRUE on success or FALSE on failure.
1562 | * Use Memcached::getResultCode if necessary.
1563 | */
1564 | public function setMulti(array $items, $expiration = 0)
1565 | {
1566 | foreach ($items as $key => $value) {
1567 | if (!$this->set($key, $value, $expiration)) {
1568 | return false;
1569 | }
1570 | }
1571 |
1572 | return true;
1573 | }
1574 |
1575 | /**
1576 | * (PECL memcached >= 0.1.0)
1577 | * Store multiple items on a specific server
1578 | *
1579 | * @link http://php.net/manual/en/memcached.setmultibykey.php
1580 | * @param string $server_key The key identifying the server to store the value on or retrieve it from.
1581 | * @param array $items An array of key/value pairs to store on the server.
1582 | * @param int $expiration [optional] The expiration time, defaults to 0. See Expiration Times for more info.
1583 | * @return bool TRUE on success or FALSE on failure.
1584 | * Use Memcached::getResultCode if necessary.
1585 | */
1586 | public function setMultiByKey($server_key, array $items, $expiration = null)
1587 | {
1588 | foreach ($items as $key => $value) {
1589 | if (!$this->setByKey($server_key, $key, $value, $expiration)) {
1590 | return false;
1591 | }
1592 | }
1593 |
1594 | return true;
1595 | }
1596 |
1597 | /**
1598 | * (PECL memcached >= 0.1.0)
1599 | * Set a Memcached option
1600 | *
1601 | * @link http://php.net/manual/en/memcached.setoption.php
1602 | * @param int $option
1603 | * @param mixed $value
1604 | * @return bool TRUE on success or FALSE on failure.
1605 | */
1606 | public function setOption($option, $value)
1607 | {
1608 | switch ($option) {
1609 | case self::OPT_COMPRESSION;
1610 | $value = (bool)$value;
1611 | break;
1612 |
1613 | case self::OPT_COMPRESSION_TYPE:
1614 | {
1615 | switch ($value) {
1616 | case 'fastlz':
1617 | case self::COMPRESSION_FASTLZ;
1618 | if (\function_exists('fastlz_compress')) {
1619 | $value = self::COMPRESSION_FASTLZ;
1620 | } // Fallback to ZLIB
1621 | elseif (\function_exists('gzcompress')) {
1622 | $value = self::COMPRESSION_ZLIB;
1623 | } else {
1624 | return $this->_return(false, self::RES_INVALID_ARGUMENTS);
1625 | }
1626 | break;
1627 |
1628 | case 'zlib':
1629 | case self::COMPRESSION_ZLIB;
1630 | if (\function_exists('gzcompress')) {
1631 | $value = self::COMPRESSION_ZLIB;
1632 | } else {
1633 | return $this->_return(false, self::RES_INVALID_ARGUMENTS);
1634 | }
1635 | break;
1636 |
1637 | default:
1638 | return $this->_return(false, self::RES_INVALID_ARGUMENTS);
1639 | }
1640 | }
1641 | break;
1642 |
1643 | case self::OPT_SERIALIZER:
1644 | {
1645 | switch ($value) {
1646 | case 'igbinary':
1647 | case self::SERIALIZER_IGBINARY:
1648 | $value = \function_exists('igbinary_serialize') ? self::SERIALIZER_IGBINARY : self::SERIALIZER_PHP;
1649 | break;
1650 |
1651 | case 'msgpack':
1652 | case self::SERIALIZER_MSGPACK:
1653 | $value = \function_exists('msgpack_pack') ? self::SERIALIZER_MSGPACK : self::SERIALIZER_PHP;
1654 | break;
1655 |
1656 | case 'php':
1657 | case self::SERIALIZER_PHP:
1658 | $value = self::SERIALIZER_PHP;
1659 | break;
1660 | case 'json':
1661 | case self::SERIALIZER_JSON:
1662 | $value = self::SERIALIZER_JSON;
1663 | break;
1664 |
1665 | case 'json_array':
1666 | case self::SERIALIZER_JSON_ARRAY:
1667 | $value = self::SERIALIZER_JSON_ARRAY;
1668 | break;
1669 |
1670 | default:
1671 | return $this->_return(false, self::RES_INVALID_ARGUMENTS);
1672 | }
1673 | }
1674 | break;
1675 | }
1676 |
1677 | $this->options[$this->options_id][$option] = $value;
1678 |
1679 | return $this->_return(true);
1680 | }
1681 |
1682 | /**
1683 | * (PECL memcached >= 2.0.0)
1684 | * Set Memcached options
1685 | *
1686 | * @link http://php.net/manual/en/memcached.setoptions.php
1687 | * @param array $options An associative array of options where the key is the option to set and the value is the new value for the option.
1688 | * @return bool TRUE on success or FALSE on failure.
1689 | */
1690 | public function setOptions(array $options)
1691 | {
1692 | foreach ($options as $option => $value) {
1693 | if (!$this->setOption($option, $value)) {
1694 | return false;
1695 | }
1696 | }
1697 |
1698 | return true;
1699 | }
1700 |
1701 | /**
1702 | * (PECL memcached >= 2.0.0)
1703 | * Set the credentials to use for authentication
1704 | *
1705 | * @link http://php.net/manual/en/memcached.setsaslauthdata.php
1706 | * @param string $username The username to use for authentication.
1707 | * @param string $password The password to use for authentication.
1708 | * @return void
1709 | */
1710 | public function setSaslAuthData(/** @noinspection PhpUnusedParameterInspection */ $username, $password)
1711 | {
1712 | throw new \BadMethodCallException(\sprintf('%s is not emulated.', __METHOD__));
1713 | }
1714 |
1715 | /**
1716 | * (PECL memcached >= 2.0.0)
1717 | * Set a new expiration on an item
1718 | *
1719 | * @link http://php.net/manual/en/memcached.touch.php
1720 | * @param string $key The key under which to store the value.
1721 | * @param int $expiration The expiration time, defaults to 0. See Expiration Times for more info.
1722 | * @return bool TRUE on success or FALSE on failure.
1723 | * Use Memcached::getResultCode if necessary.
1724 | */
1725 | public function touch($key, $expiration)
1726 | {
1727 | // Note: we use only single default server.
1728 | return $this->touchByKey(null, $key, $expiration);
1729 | }
1730 |
1731 | /**
1732 | * (PECL memcached >= 2.0.0)
1733 | * Set a new expiration on an item on a specific server
1734 | *
1735 | * @link http://php.net/manual/en/memcached.touchbykey.php
1736 | * @param string $server_key The key identifying the server to store the value on or retrieve it from.
1737 | * @param string $key The key under which to store the value.
1738 | * @param int $expiration The expiration time, defaults to 0. See Expiration Times for more info.
1739 | * @return bool TRUE on success or FALSE on failure.
1740 | * Use Memcached::getResultCode if necessary.
1741 | */
1742 | public function touchByKey($server_key, $key, $expiration)
1743 | {
1744 | $real_key = $this->_getKey($key);
1745 | $expiration = (int)$expiration;
1746 |
1747 | // touch [noreply]\r\n
1748 | if ((false !== $response = $this->_query("touch $real_key $expiration", $server_key))
1749 | // Valid response.
1750 | &&
1751 | isset(self::_TOUCH_SIGNALS[$response])
1752 | ) {
1753 | return $this->_return(self::_TOUCH_SIGNALS[$response] === self::RES_SUCCESS,
1754 | self::_TOUCH_SIGNALS[$response]);
1755 | }
1756 |
1757 | return $this->_return(false, self::RES_FAILURE, __METHOD__ . ' failed.');
1758 | }
1759 |
1760 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1761 | // Own helper methods.
1762 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1763 |
1764 |
1765 | /**
1766 | * Returns real item key.
1767 | *
1768 | * @param string $key
1769 | *
1770 | * @return string
1771 | */
1772 | protected function _getKey($key)
1773 | {
1774 | return \addslashes($this->options[$this->options_id][self::OPT_PREFIX_KEY] . $key);
1775 | }
1776 |
1777 | /**
1778 | * Returns real items keys.
1779 | *
1780 | * @param string[] $keys
1781 | *
1782 | * @return string[]
1783 | */
1784 | protected function _getKeys(array $keys)
1785 | {
1786 | $real_keys = [];
1787 |
1788 | foreach ($keys as $key) {
1789 | $real_keys[$key] = \addslashes($this->options[$this->options_id][self::OPT_PREFIX_KEY] . $key);
1790 | }
1791 |
1792 | return $real_keys;
1793 | }
1794 |
1795 | /**
1796 | * Returns socket by server key.
1797 | *
1798 | * @param string|null $server_key Default server socket is used if NULL.
1799 | * @return resource|false
1800 | */
1801 | protected function _getSocket($server_key = null)
1802 | {
1803 | // Use default server key.
1804 | if ($server_key === null) {
1805 | if ($this->current_server_key === null) {
1806 | // Check if we have servers.
1807 | if (empty($this->servers)) {
1808 | return $this->_return(false, self::RES_NO_SERVERS, 'NO SERVERS DEFINED');
1809 | }
1810 |
1811 | // Use first server by default.
1812 | $this->current_server_key = \key($this->servers);
1813 | }
1814 |
1815 | /** @noinspection CallableParameterUseCaseInTypeContextInspection */
1816 | $server_key = $this->current_server_key;
1817 | }
1818 |
1819 | if (!isset($this->sockets[$server_key])) {
1820 | // Check that server key exists.
1821 | if (!isset($this->servers[$server_key])) {
1822 | return false;
1823 | }
1824 |
1825 | $server = $this->servers[$server_key];
1826 |
1827 | try {
1828 | if (false === $this->sockets[$server_key] = \fsockopen($server['host'], $server['port'], $error,
1829 | $errstr)) {
1830 | throw new \RuntimeException(\sprintf('Code %s: %s', $error, $errstr));
1831 | }
1832 | } catch (\Throwable $e) {
1833 | throw new \RuntimeException(\sprintf('%s connection failed: connecting to "%s" error: %s', __CLASS__,
1834 | $server_key, $e->getMessage()));
1835 | }
1836 | }
1837 |
1838 | return $this->sockets[$server_key];
1839 | }
1840 |
1841 | /**
1842 | * Sends command to a server and returns single result.
1843 | *
1844 | * @param string $command
1845 | * @param string $server_key
1846 | * @param resource|bool $socket
1847 | * @return string|false False on error.
1848 | */
1849 | protected function _query($command, $server_key = null, &$socket = null)
1850 | {
1851 | if (false === $socket = $this->_getSocket($server_key)) {
1852 | return false;
1853 | }
1854 |
1855 | if (\fwrite($socket, $command . "\r\n") < 1) {
1856 | return false;
1857 | }
1858 |
1859 | // Read first line.
1860 | if (false === $buffer = \fgets($socket)) {
1861 | return false;
1862 | }
1863 |
1864 | // Check command response signal.
1865 | [$command_name,] = \explode(' ', $command, 2);
1866 |
1867 | // Check errors if unknown signal.
1868 | if (!isset(self::_SIGNALS[$command_name][\rtrim($buffer)])) {
1869 | // Check invalid response
1870 | $this->_checkInvalidResponse($server_key, $command, $buffer);
1871 | }
1872 |
1873 | return \rtrim($buffer);
1874 | }
1875 |
1876 | /**
1877 | * @param string $server_key
1878 | * @param string $command
1879 | * @param string $response
1880 | */
1881 | protected function _checkInvalidResponse($server_key, $command, $response)
1882 | {
1883 | // RESPONSE_ERROR mostly means non-existent command.
1884 | if ($response === self::RESPONSE_ERROR) {
1885 | throw new \RuntimeException(
1886 | \sprintf(
1887 | '%s on sending command "%s" to server "%s".',
1888 | self::RESPONSE_ERROR,
1889 | $command,
1890 | $server_key ?? $this->current_server_key
1891 | )
1892 | );
1893 | }
1894 |
1895 | if (\preg_match('/' . self::RESPONSE_CLIENT_ERROR . ' (.*)\R?/mu', $response, $error) > 0) {
1896 | throw new \RuntimeException(
1897 | \sprintf(
1898 | '%s error "%s" on sending command "%s" to server "%s".',
1899 | self::RESPONSE_CLIENT_ERROR,
1900 | $error[1],
1901 | $command,
1902 | $server_key ?? $this->current_server_key
1903 | )
1904 | );
1905 | }
1906 |
1907 | if (\preg_match('/' . self::RESPONSE_SERVER_ERROR . ' (.*)\R?/mu', $response, $error) > 0) {
1908 | throw new \RuntimeException(
1909 | \sprintf(
1910 | '%s error "%s" on sending command "%s" to server "%s".',
1911 | self::RESPONSE_SERVER_ERROR,
1912 | $error[1],
1913 | $command,
1914 | $server_key ?? $this->current_server_key
1915 | )
1916 | );
1917 | }
1918 | }
1919 |
1920 | /**
1921 | * Closes socket connections.
1922 | *
1923 | * @return bool
1924 | */
1925 | protected function _closeSockets()
1926 | {
1927 | foreach ($this->sockets as $i => $socket) {
1928 | \fclose($socket);
1929 | unset($this->sockets[$i]);
1930 | }
1931 |
1932 | return true;
1933 | }
1934 |
1935 | /**
1936 | * Serialize a value.
1937 | *
1938 | * @param mixed $value
1939 | * @param int $flags
1940 | * @param int $bytes
1941 | * @return bool
1942 | */
1943 | protected function _serialize(&$value, &$flags, &$bytes)
1944 | {
1945 | switch (\gettype($value)) {
1946 | case 'string':
1947 | self::MEMC_VAL_SET_TYPE($flags, self::MEMC_VAL_IS_STRING);
1948 | break;
1949 |
1950 | case 'integer':
1951 | self::MEMC_VAL_SET_TYPE($flags, self::MEMC_VAL_IS_LONG);
1952 | break;
1953 |
1954 | case 'double':
1955 | self::MEMC_VAL_SET_TYPE($flags, self::MEMC_VAL_IS_DOUBLE);
1956 | break;
1957 |
1958 | case 'boolean':
1959 | self::MEMC_VAL_SET_TYPE($flags, self::MEMC_VAL_IS_BOOL);
1960 | break;
1961 |
1962 | default:
1963 | {
1964 |
1965 | switch ($this->options[$this->options_id][self::OPT_SERIALIZER]) {
1966 | case self::SERIALIZER_IGBINARY:
1967 | /** @noinspection PhpComposerExtensionStubsInspection */
1968 | $value = \igbinary_serialize($value);
1969 | self::MEMC_VAL_SET_TYPE($flags, self::MEMC_VAL_IS_IGBINARY);
1970 | break;
1971 |
1972 | case self::SERIALIZER_JSON:
1973 | case self::SERIALIZER_JSON_ARRAY:
1974 | $value = \json_encode($value);
1975 | self::MEMC_VAL_SET_TYPE($flags, self::MEMC_VAL_IS_JSON);
1976 | break;
1977 |
1978 | case self::SERIALIZER_MSGPACK:
1979 | /** @noinspection PhpUndefinedFunctionInspection */
1980 | $value = \msgpack_pack($value);
1981 | self::MEMC_VAL_SET_TYPE($flags, self::MEMC_VAL_IS_MSGPACK);
1982 | break;
1983 |
1984 | case self::SERIALIZER_PHP:
1985 | default:
1986 | $value = \serialize($value);
1987 | self::MEMC_VAL_SET_TYPE($flags, self::MEMC_VAL_IS_SERIALIZED);
1988 | break;
1989 | }
1990 | }
1991 | }
1992 |
1993 | $value = (string)$value;
1994 | $bytes = \strlen($value);
1995 |
1996 | // Compress, but not for values below the threshold
1997 | if ($bytes
1998 | &&
1999 | $this->options[$this->options_id][self::OPT_COMPRESSION]
2000 | &&
2001 | // Check compression threshold (2000 by default)
2002 | $bytes > $this->options[$this->options_id][self::OPT_COMPRESSION_THRESHOLD]
2003 | ) {
2004 | switch ($this->options[$this->options_id][self::OPT_COMPRESSION_TYPE]) {
2005 | case 'fastlz':
2006 | case self::COMPRESSION_FASTLZ:
2007 | /** @noinspection PhpUndefinedFunctionInspection */
2008 | $value2 = \fastlz_compress($value);
2009 | $compression_flag = self::MEMC_VAL_COMPRESSION_FASTLZ;
2010 | break;
2011 |
2012 | case 'zlib':
2013 | case self::COMPRESSION_ZLIB:
2014 | default:
2015 | /** @noinspection PhpComposerExtensionStubsInspection */
2016 | $value2 = \gzcompress($value);
2017 | $compression_flag = self::MEMC_VAL_COMPRESSION_ZLIB;
2018 | break;
2019 | }
2020 |
2021 | $bytes2 = \strlen($value2);
2022 |
2023 | // Check compression factor (float 1.3 by default)
2024 | // Compressed length should be not X larger than original.
2025 | if ($bytes > $bytes2 * $this->options[$this->options_id][self::OPT_COMPRESSION_FACTOR]) {
2026 | $value = $value2;
2027 | $bytes = $bytes2;
2028 | self::MEMC_VAL_SET_FLAG($flags, self::MEMC_VAL_COMPRESSED | $compression_flag);
2029 | }
2030 |
2031 | // todo - always raise RES_PAYLOAD_FAILURE on any error.
2032 | }
2033 |
2034 | // todo - check all serializations and return false on error.
2035 | // todo - always raise RES_PAYLOAD_FAILURE on any error.
2036 |
2037 | return true;
2038 | }
2039 |
2040 | /**
2041 | * Unserialize a value.
2042 | *
2043 | * @param mixed $value
2044 | * @param int $flags
2045 | * @return mixed
2046 | */
2047 | protected function _unserialize($value, $flags)
2048 | {
2049 | // Decompress first.
2050 | if (self::MEMC_VAL_HAS_FLAG($flags, self::MEMC_VAL_COMPRESSED)) {
2051 | if (self::MEMC_VAL_HAS_FLAG($flags, self::MEMC_VAL_COMPRESSION_ZLIB)) {
2052 | /** @noinspection PhpComposerExtensionStubsInspection */
2053 | $value = \gzuncompress($value);
2054 | } elseif (self::MEMC_VAL_HAS_FLAG($flags, self::MEMC_VAL_COMPRESSION_FASTLZ)) {
2055 | /** @noinspection PhpUndefinedFunctionInspection */
2056 | $value = \fastlz_decompress($value);
2057 | }
2058 | }
2059 |
2060 | switch (self::MEMC_VAL_GET_TYPE($flags)) {
2061 | case self::MEMC_VAL_IS_STRING:
2062 | break;
2063 |
2064 | case self::MEMC_VAL_IS_LONG:
2065 | $value = (int)$value;
2066 | break;
2067 |
2068 | case self::MEMC_VAL_IS_DOUBLE:
2069 | $value = (double)$value;
2070 | break;
2071 |
2072 | case self::MEMC_VAL_IS_BOOL:
2073 | $value = (bool)$value;
2074 | break;
2075 |
2076 | case self::MEMC_VAL_IS_SERIALIZED:
2077 | /** @noinspection UnserializeExploitsInspection */
2078 | $value = \unserialize($value);
2079 | break;
2080 |
2081 | case self::MEMC_VAL_IS_IGBINARY:
2082 | /** @noinspection PhpComposerExtensionStubsInspection */
2083 | $value = \igbinary_unserialize($value);
2084 | break;
2085 |
2086 | case self::MEMC_VAL_IS_JSON:
2087 | $value = \json_decode($value,
2088 | $this->options[$this->options_id][self::OPT_SERIALIZER] === self::SERIALIZER_JSON_ARRAY);
2089 | break;
2090 |
2091 | case self::MEMC_VAL_IS_MSGPACK:
2092 | /** @noinspection PhpUndefinedFunctionInspection */
2093 | $value = \msgpack_unpack($value);
2094 | break;
2095 |
2096 | default:
2097 | throw new \RuntimeException('unknown payload type');
2098 | }
2099 |
2100 | // todo - always raise RES_PAYLOAD_FAILURE on any error.
2101 |
2102 | return $value;
2103 |
2104 | }
2105 |
2106 | /**
2107 | * Utility return.
2108 | *
2109 | * @param mixed $result
2110 | * @param int $result_code
2111 | * @param string $result_message
2112 | * @return mixed
2113 | */
2114 | protected function _return($result, $result_code = self::RES_SUCCESS, $result_message = '')
2115 | {
2116 | $this->result_code = $result_code;
2117 | $this->result_message = $result_message;
2118 |
2119 | return $result;
2120 | }
2121 |
2122 | /**
2123 | * Destructor to close opened sockets.
2124 | */
2125 | public function __destruct()
2126 | {
2127 | $this->_closeSockets();
2128 | }
2129 |
2130 | /**
2131 | * @param int $start
2132 | * @param int $n_bits
2133 | * @return int
2134 | */
2135 | public static function MEMC_CREATE_MASK($start, $n_bits)
2136 | {
2137 | return (((1 << $n_bits) - 1) << $start);
2138 | }
2139 |
2140 | /**
2141 | * @param int $flags
2142 | * @return int
2143 | */
2144 | public static function MEMC_VAL_GET_TYPE($flags)
2145 | {
2146 | return ($flags & self::MEMC_MASK_TYPE);
2147 |
2148 | }
2149 |
2150 | /**
2151 | * @param int $flags
2152 | * @param int $type
2153 | */
2154 | public static function MEMC_VAL_SET_TYPE(&$flags, $type)
2155 | {
2156 | $flags |= ($type & self::MEMC_MASK_TYPE);
2157 | }
2158 |
2159 | /**
2160 | * @param int $flags
2161 | * @return int
2162 | */
2163 | public static function MEMC_VAL_GET_FLAGS($flags)
2164 | {
2165 | return (($flags & self::MEMC_MASK_INTERNAL) >> 4);
2166 | }
2167 |
2168 | /**
2169 | * @param int $flags
2170 | * @param int $flag
2171 | */
2172 | public static function MEMC_VAL_SET_FLAG(&$flags, $flag)
2173 | {
2174 | $flags |= (($flag << 4) & self::MEMC_MASK_INTERNAL);
2175 | }
2176 |
2177 | /**
2178 | * @param int $flags
2179 | * @param int $flag
2180 | * @return bool
2181 | */
2182 | public static function MEMC_VAL_HAS_FLAG($flags, $flag)
2183 | {
2184 | return ((self::MEMC_VAL_GET_FLAGS($flags) & $flag) === $flag);
2185 | }
2186 |
2187 | /**
2188 | * @param int $flags
2189 | * @param int $flag
2190 | */
2191 | public static function MEMC_VAL_DEL_FLAG(&$flags, $flag)
2192 | {
2193 | $flags &= (~(($flag << 4) & self::MEMC_MASK_INTERNAL));
2194 | }
2195 | }
2196 |
--------------------------------------------------------------------------------
/src/MemcachedException.php:
--------------------------------------------------------------------------------
1 |
5 | *
6 | * For the full copyright and license information, please view the LICENSE
7 | * file that was distributed with this source code.
8 | */
9 |
10 | /**
11 | * @link http://php.net/manual/en/class.memcachedexception.php
12 | */
13 | class MemcachedException extends \RuntimeException
14 | {
15 | }
16 |
--------------------------------------------------------------------------------
/tests/MemcachedEmulatorTest.php:
--------------------------------------------------------------------------------
1 |
5 | *
6 | * For the full copyright and license information, please view the LICENSE
7 | * file that was distributed with this source code.
8 | */
9 |
10 | namespace Avantarm\MemcachedEmulator\Tests;
11 |
12 | use Avantarm\MemcachedEmulator\MemcachedEmulator;
13 | use PHPUnit\Framework\TestCase;
14 |
15 | /**
16 | * Class MemcachedEmulatorTest
17 | *
18 | * @package Avantarm\WincacheEmulator
19 | * @coversDefaultClass \Avantarm\MemcachedEmulator\MemcachedEmulator
20 | */
21 | class MemcachedEmulatorTest extends TestCase
22 | {
23 | public const SERVER_KEY = '127.0.0.1:11211';
24 |
25 | /**
26 | * @var MemcachedEmulator
27 | */
28 | protected $emulator;
29 |
30 | /**
31 | * @inheritdoc
32 | */
33 | public function setUp(): void
34 | {
35 | $this->emulator = new MemcachedEmulator();
36 |
37 | $this->emulator->addServer('127.0.0.1', 11211);
38 |
39 | // Flush doesn't actually delete all keys but only expires.
40 | //static::$m->flush();
41 |
42 | $this->emulator->delete('key1');
43 | $this->emulator->delete('key2');
44 | }
45 |
46 | /**
47 | * @inheritdoc
48 | */
49 | public function tearDown(): void
50 | {
51 | unset($this->emulator);
52 | }
53 |
54 | /**
55 | * @covers ::add
56 | */
57 | public function testAddMissed()
58 | {
59 | static::assertTrue($this->emulator->add('key1', '1'));
60 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
61 | static::assertEquals('1', $this->emulator->get('key1'));
62 | }
63 |
64 | /**
65 | * @covers ::add
66 | */
67 | public function testAddExists()
68 | {
69 | static::assertTrue($this->emulator->set('key1', '12'));
70 | static::assertFalse($this->emulator->add('key1', '2'));
71 | static::assertEquals(MemcachedEmulator::RES_NOTSTORED, $this->emulator->getResultCode());
72 | }
73 |
74 | /**
75 | * @covers ::addByKey
76 | */
77 | public function testAddByKeyMissed()
78 | {
79 | static::assertTrue($this->emulator->addByKey(static::SERVER_KEY, 'key1', '1'));
80 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
81 | static::assertEquals('1', $this->emulator->getByKey(static::SERVER_KEY, 'key1'));
82 | }
83 |
84 | /**
85 | * @covers ::addByKey
86 | */
87 | public function testAddByKeyExists()
88 | {
89 | static::assertTrue($this->emulator->setByKey(static::SERVER_KEY, 'key1', '1'));
90 | static::assertFalse($this->emulator->addByKey(static::SERVER_KEY, 'key1', '2'));
91 | static::assertEquals(MemcachedEmulator::RES_NOTSTORED, $this->emulator->getResultCode());
92 | }
93 |
94 | /**
95 | * @covers ::addServer
96 | */
97 | public function testAddServer()
98 | {
99 | static::assertTrue($this->emulator->addServer('127.0.0.2', 11211));
100 | }
101 |
102 | /**
103 | * @covers ::addServers
104 | */
105 | public function testAddServers()
106 | {
107 | static::assertTrue($this->emulator->addServers(
108 | [
109 | ['127.0.0.3', 11211, 100],
110 | ['127.0.0.4', 11211, 100],
111 | ]
112 | ));
113 | }
114 |
115 | /**
116 | * @covers ::append
117 | */
118 | public function testAppendMissed()
119 | {
120 | static::assertFalse($this->emulator->append('key1', '2'));
121 | static::assertEquals(MemcachedEmulator::RES_NOTSTORED, $this->emulator->getResultCode());
122 | }
123 |
124 | /**
125 | * @covers ::append
126 | */
127 | public function testAppendExists()
128 | {
129 | static::assertTrue($this->emulator->set('key1', '1'));
130 | static::assertTrue($this->emulator->append('key1', '2'));
131 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
132 | static::assertEquals('12', $this->emulator->get('key1'));
133 | }
134 |
135 | /**
136 | * @covers ::appendByKey
137 | */
138 | public function testAppendByKeyMissed()
139 | {
140 | static::assertFalse($this->emulator->appendByKey(static::SERVER_KEY, 'key1', '1'));
141 | static::assertEquals(MemcachedEmulator::RES_NOTSTORED, $this->emulator->getResultCode());
142 | }
143 |
144 | /**
145 | * @covers ::appendByKey
146 | */
147 | public function testAppendByKeyExists()
148 | {
149 | static::assertTrue($this->emulator->setByKey(static::SERVER_KEY, 'key1', '1'));
150 | static::assertTrue($this->emulator->appendByKey(static::SERVER_KEY, 'key1', '1'));
151 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
152 | static::assertEquals('11', $this->emulator->getByKey(static::SERVER_KEY, 'key1'));
153 | }
154 |
155 | /**
156 | * @covers ::cas
157 | */
158 | public function testCas()
159 | {
160 | static::assertTrue($this->emulator->set('key1', '1'));
161 |
162 | $result = $this->emulator->get('key1', null, MemcachedEmulator::GET_EXTENDED);
163 | if (!\array_key_exists('value', $result) || !\array_key_exists('cas', $result)) {
164 | static::markTestIncomplete('Could not get cas token.');
165 | }
166 |
167 | static::assertFalse($this->emulator->cas(767867, 'key1', '2'));
168 | static::assertTrue($this->emulator->cas($result['cas'], 'key1', '2'));
169 | static::assertEquals('2', $this->emulator->get('key1'));
170 | }
171 |
172 | /**
173 | * @covers ::casByKey
174 | */
175 | public function testCasByKey()
176 | {
177 | static::assertTrue($this->emulator->set('key1', '1'));
178 |
179 | $result = $this->emulator->get('key1', null, MemcachedEmulator::GET_EXTENDED);
180 | if (!\array_key_exists('value', $result) || !\array_key_exists('cas', $result)) {
181 | static::markTestIncomplete('Could not get cas token.');
182 | }
183 |
184 | static::assertFalse($this->emulator->casByKey(767867, static::SERVER_KEY, 'key1', '2'));
185 | static::assertTrue($this->emulator->casByKey($result['cas'], static::SERVER_KEY, 'key1', '2'));
186 | static::assertEquals('2', $this->emulator->get('key1'));
187 | }
188 |
189 | /**
190 | * @covers ::decrement
191 | */
192 | public function testDecrementMissed()
193 | {
194 | // If the operation decrease the value below 0, the new value will be 0.
195 | static::assertEquals(1, $this->emulator->decrement('key1', 1, 2));
196 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
197 | static::assertEquals(2, $this->emulator->get('key1'));
198 | }
199 |
200 | /**
201 | * @covers ::decrement
202 | */
203 | public function testDecrementExists()
204 | {
205 | static::assertTrue($this->emulator->set('key1', '3'));
206 |
207 | // If the operation decrease the value below 0, the new value will be 0.
208 | static::assertEquals(2, $this->emulator->decrement('key1', 1, 2));
209 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
210 | static::assertEquals(2, $this->emulator->get('key1'));
211 | }
212 |
213 | /**
214 | * @covers ::decrementByKey
215 | */
216 | public function testDecrementByKeyMissed()
217 | {
218 | // If the operation decrease the value below 0, the new value will be 0.
219 | static::assertEquals(1, $this->emulator->decrementByKey(static::SERVER_KEY, 'key1', 1, 2));
220 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
221 | static::assertEquals(2, $this->emulator->get('key1'));
222 | }
223 |
224 | /**
225 | * @covers ::decrement
226 | */
227 | public function testDecrementByKeyExists()
228 | {
229 | static::assertTrue($this->emulator->set('key1', '3'));
230 |
231 | // If the operation decrease the value below 0, the new value will be 0.
232 | static::assertEquals(2, $this->emulator->decrementByKey(static::SERVER_KEY, 'key1', 1, 2));
233 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
234 | static::assertEquals(2, $this->emulator->get('key1'));
235 | }
236 |
237 | /**
238 | * @covers ::delete
239 | */
240 | public function testDelete()
241 | {
242 | static::assertFalse($this->emulator->delete('key1'));
243 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
244 |
245 | static::assertTrue($this->emulator->set('key1', '1'));
246 | static::assertTrue($this->emulator->delete('key1'));
247 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
248 | static::assertFalse($this->emulator->get('key1'));
249 | }
250 |
251 | /**
252 | * @covers ::deleteByKey
253 | */
254 | public function testDeleteByKey()
255 | {
256 | static::assertFalse($this->emulator->deleteByKey(static::SERVER_KEY, 'key1'));
257 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
258 |
259 | static::assertTrue($this->emulator->setByKey(static::SERVER_KEY, 'key1', '1'));
260 | static::assertTrue($this->emulator->deleteByKey(static::SERVER_KEY, 'key1'));
261 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
262 | static::assertFalse($this->emulator->getByKey(static::SERVER_KEY, 'key1'));
263 | }
264 |
265 | /**
266 | * @covers ::deleteMulti
267 | */
268 | public function testDeleteMulti()
269 | {
270 | static::assertEquals([
271 | 'key1' => MemcachedEmulator::RES_NOTFOUND,
272 | 'key2' => MemcachedEmulator::RES_NOTFOUND,
273 | ], $this->emulator->deleteMulti(['key1', 'key2']));
274 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
275 |
276 | static::assertTrue($this->emulator->set('key1', '1'));
277 | static::assertEquals([
278 | 'key1' => true,
279 | 'key2' => MemcachedEmulator::RES_NOTFOUND,
280 | ], $this->emulator->deleteMulti(['key1', 'key2']));
281 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
282 | static::assertFalse($this->emulator->get('key1'));
283 |
284 | static::assertTrue($this->emulator->set('key1', '1'));
285 | static::assertTrue($this->emulator->set('key2', '2'));
286 | static::assertEquals([
287 | 'key1' => true,
288 | 'key2' => true,
289 | ], $this->emulator->deleteMulti(['key1', 'key2']));
290 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
291 | static::assertFalse($this->emulator->get('key1'));
292 | static::assertFalse($this->emulator->get('key2'));
293 | }
294 |
295 | /**
296 | * @covers ::deleteMultiByKey
297 | */
298 | public function testDeleteMultiByKey()
299 | {
300 | static::assertEquals([
301 | 'key1' => MemcachedEmulator::RES_NOTFOUND,
302 | 'key2' => MemcachedEmulator::RES_NOTFOUND,
303 | ], $this->emulator->deleteMultiByKey(static::SERVER_KEY, ['key1', 'key2']));
304 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
305 |
306 | static::assertTrue($this->emulator->set('key1', '1'));
307 | static::assertEquals([
308 | 'key1' => true,
309 | 'key2' => MemcachedEmulator::RES_NOTFOUND,
310 | ], $this->emulator->deleteMultiByKey(static::SERVER_KEY, ['key1', 'key2']));
311 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
312 | static::assertFalse($this->emulator->getByKey(static::SERVER_KEY, 'key1'));
313 |
314 | static::assertTrue($this->emulator->set('key1', '1'));
315 | static::assertTrue($this->emulator->set('key2', '2'));
316 | static::assertEquals([
317 | 'key1' => true,
318 | 'key2' => true,
319 | ], $this->emulator->deleteMultiByKey(static::SERVER_KEY, ['key1', 'key2']));
320 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
321 | static::assertFalse($this->emulator->getByKey(static::SERVER_KEY, 'key1'));
322 | static::assertFalse($this->emulator->getByKey(static::SERVER_KEY, 'key2'));
323 | }
324 |
325 | /**
326 | * @covers ::flush
327 | * @see testFlushDelay() as well.
328 | */
329 | public function testFlush()
330 | {
331 | static::assertTrue($this->emulator->flush());
332 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
333 |
334 | static::assertTrue($this->emulator->set('key1', '1'));
335 | static::assertTrue($this->emulator->set('key2', '2'));
336 |
337 | static::assertTrue($this->emulator->flush());
338 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
339 |
340 | static::assertFalse($this->emulator->get('key1'));
341 | static::assertFalse($this->emulator->get('key2'));
342 | }
343 |
344 | /**
345 | * @covers ::get
346 | */
347 | public function testGet()
348 | {
349 | foreach (static::getTestValues() as $type => $value) {
350 | static::assertTrue($this->emulator->set('key1', $value), \sprintf('Failed on "%s" value.', $type));
351 | static::assertEquals($value, $this->emulator->get('key1'));
352 | /** @noinspection DisconnectedForeachInstructionInspection */
353 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
354 |
355 | // Test case
356 | $actual = $this->emulator->get('key1', null, MemcachedEmulator::GET_EXTENDED);
357 | static::assertIsArray($actual);
358 | static::assertArrayHasKey('value', $actual);
359 | static::assertArrayHasKey('cas', $actual);
360 | static::assertEquals($value, $actual['value']);
361 | }
362 |
363 | static::assertFalse($this->emulator->get('key2'));
364 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
365 | }
366 |
367 | /**
368 | * @covers ::get
369 | */
370 | public function testGetCompressed()
371 | {
372 | $this->emulator->setOption(MemcachedEmulator::OPT_COMPRESSION, true);
373 | $this->emulator->setOption(MemcachedEmulator::OPT_COMPRESSION_TYPE, MemcachedEmulator::COMPRESSION_ZLIB);
374 |
375 | foreach (static::getTestValues() as $type => $value) {
376 | static::assertTrue($this->emulator->set('key1', $value), \sprintf('Failed on "%s" value.', $type));
377 | static::assertEquals($value, $this->emulator->get('key1'));
378 | /** @noinspection DisconnectedForeachInstructionInspection */
379 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
380 | }
381 |
382 | static::assertFalse($this->emulator->get('key2'));
383 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
384 |
385 | $this->emulator->setOption(MemcachedEmulator::OPT_COMPRESSION, false);
386 | }
387 |
388 | /**
389 | * @covers ::getByKey
390 | */
391 | public function testGetByKey()
392 | {
393 | foreach (static::getTestValues() as $type => $value) {
394 | static::assertTrue($this->emulator->setByKey(static::SERVER_KEY, 'key1', $value),
395 | \sprintf('Failed on "%s" value: %s.', $type, $this->emulator->getResultCode()));
396 | static::assertEquals($value, $this->emulator->getByKey(static::SERVER_KEY, 'key1'));
397 | /** @noinspection DisconnectedForeachInstructionInspection */
398 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
399 | }
400 |
401 | static::assertFalse($this->emulator->getByKey(static::SERVER_KEY, 'key2'));
402 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
403 | }
404 |
405 | /**
406 | * @covers ::getAllKeys
407 | */
408 | public function testGetAllKeys()
409 | {
410 | // Delete all existing keys first
411 | $this->emulator->deleteMulti($this->emulator->getAllKeys());
412 |
413 | static::assertTrue($this->emulator->set('key1', '1'));
414 | static::assertTrue($this->emulator->set('key2', '2'));
415 |
416 | static::assertEqualsCanonicalizing(['key1', 'key2'], $this->emulator->getAllKeys());
417 | }
418 |
419 | /**
420 | * @covers ::getMulti
421 | */
422 | public function testGetMulti()
423 | {
424 | static::assertEquals([], $this->emulator->getMulti(['key1', 'key2']));
425 |
426 | static::assertTrue($this->emulator->set('key1', '1'));
427 |
428 | static::assertEqualsCanonicalizing(['key1' => '1'], $this->emulator->getMulti(['key1', 'key2']));
429 |
430 | static::assertTrue($this->emulator->set('key1', '1'));
431 | static::assertTrue($this->emulator->set('key2', '2'));
432 |
433 | static::assertEqualsCanonicalizing(['key1' => '1', 'key2' => '2'], $this->emulator->getMulti(['key1', 'key2']));
434 |
435 | $values = self::getTestValues();
436 | $keys = \array_keys($values);
437 |
438 | static::assertTrue($this->emulator->setMulti($values));
439 | static::assertEqualsCanonicalizing($values, $this->emulator->getMulti($keys));
440 | static::assertEquals(\array_fill_keys($keys, true), $this->emulator->deleteMulti($keys));
441 |
442 | // Test Preserve order: actually always
443 |
444 | // Test CAS
445 | static::assertTrue($this->emulator->setMulti($values));
446 |
447 | $actual = $this->emulator->getMulti($keys, MemcachedEmulator::GET_EXTENDED);
448 | static::assertIsArray($actual);
449 |
450 | foreach ($values as $key => $value) {
451 | static::assertArrayHasKey($key, $actual);
452 | static::assertArrayHasKey('value', $actual[$key]);
453 | static::assertArrayHasKey('cas', $actual[$key]);
454 | static::assertEquals($value, $actual[$key]['value']);
455 | }
456 | }
457 |
458 | /**
459 | * @covers ::getMultiByKey
460 | */
461 | public function testGetMultiByKey()
462 | {
463 | static::assertEquals([], $this->emulator->getMultiByKey(static::SERVER_KEY, ['key1', 'key2']));
464 |
465 | static::assertTrue($this->emulator->setByKey(static::SERVER_KEY, 'key1', '1'));
466 |
467 | static::assertEqualsCanonicalizing(['key1' => '1'],
468 | $this->emulator->getMultiByKey(static::SERVER_KEY, ['key1', 'key2']));
469 |
470 | static::assertTrue($this->emulator->setByKey(static::SERVER_KEY, 'key1', '1'));
471 | static::assertTrue($this->emulator->setByKey(static::SERVER_KEY, 'key2', '2'));
472 |
473 | static::assertEqualsCanonicalizing(['key1' => '1', 'key2' => '2'],
474 | $this->emulator->getMultiByKey(static::SERVER_KEY, ['key1', 'key2']));
475 |
476 | $values = self::getTestValues();
477 | $keys = \array_keys($values);
478 |
479 | static::assertTrue($this->emulator->setMultiByKey(static::SERVER_KEY, $values));
480 | static::assertEqualsCanonicalizing($values, $this->emulator->getMultiByKey(static::SERVER_KEY, $keys));
481 | static::assertEquals(\array_fill_keys($keys, true),
482 | $this->emulator->deleteMultiByKey(static::SERVER_KEY, $keys));
483 | }
484 |
485 | /**
486 | * @covers ::getOption
487 | */
488 | public function testGetOption()
489 | {
490 | static::assertEquals(0, $this->emulator->getOption(1234567));
491 |
492 | // Use always available SERIALIZER_JSON;
493 | static::assertTrue($this->emulator->setOption(MemcachedEmulator::OPT_SERIALIZER,
494 | MemcachedEmulator::SERIALIZER_JSON));
495 | static::assertEquals(MemcachedEmulator::SERIALIZER_JSON,
496 | $this->emulator->getOption(MemcachedEmulator::OPT_SERIALIZER));
497 |
498 | // Switch back to default serializer.
499 | $this->emulator->setOption(MemcachedEmulator::OPT_SERIALIZER, MemcachedEmulator::SERIALIZER_PHP);
500 | }
501 |
502 | /**
503 | * @covers ::getResultCode
504 | */
505 | public function testGetResultCode()
506 | {
507 | // Execute success command to reset result.
508 | static::assertTrue($this->emulator->set('key1', '1'));
509 |
510 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
511 | }
512 |
513 | /**
514 | * @covers ::getResultMessage
515 | */
516 | public function testGetResultMessage()
517 | {
518 | static::assertEquals('', $this->emulator->getResultMessage());
519 | }
520 |
521 | /**
522 | * @covers ::getServerByKey
523 | */
524 | public function testGetServerByKey()
525 | {
526 | static::assertFalse($this->emulator->getServerByKey('false_server'));
527 |
528 | $server = $this->emulator->getServerByKey(static::SERVER_KEY);
529 |
530 | static::assertIsArray($server);
531 | static::assertArrayHasKey('host', $server);
532 | static::assertArrayHasKey('port', $server);
533 | static::assertArrayHasKey('weight', $server);
534 | }
535 |
536 | /**
537 | * @covers ::getServerList
538 | */
539 | public function testGetServerList()
540 | {
541 | $servers = $this->emulator->getServerList();
542 |
543 | static::assertIsArray($servers);
544 | static::assertArrayHasKey('0', $servers);
545 |
546 | $server = \current($servers);
547 |
548 | static::assertIsArray($server);
549 | static::assertArrayHasKey('host', $server);
550 | static::assertArrayHasKey('port', $server);
551 | static::assertArrayHasKey('weight', $server);
552 | }
553 |
554 | /**
555 | * @covers ::getStats
556 | */
557 | public function testGetStats()
558 | {
559 | $stats = $this->emulator->getStats();
560 |
561 | static::assertIsArray($stats);
562 | static::assertArrayHasKey(static::SERVER_KEY, $stats);
563 |
564 | $stat = $stats[static::SERVER_KEY];
565 |
566 | static::assertArrayHasKey('pid', $stat);
567 | }
568 |
569 | /**
570 | * @covers ::getVersion
571 | */
572 |
573 | public function testGetVersion()
574 | {
575 | $version = $this->emulator->getVersion();
576 |
577 | static::assertIsArray($version);
578 | static::assertCount(\count($this->emulator->getServerList()), $version);
579 | static::assertArrayHasKey(static::SERVER_KEY, $version);
580 | }
581 |
582 | /**
583 | * @covers ::increment
584 | */
585 | public function testIncrementMissed()
586 | {
587 | // If the operation decrease the value below 0, the new value will be 0.
588 | static::assertEquals(3, $this->emulator->increment('key1', 1, 2));
589 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
590 | static::assertEquals(3, $this->emulator->get('key1'));
591 | }
592 |
593 | /**
594 | * @covers ::increment
595 | */
596 | public function testIncrementExists()
597 | {
598 | static::assertTrue($this->emulator->set('key1', '3'));
599 |
600 | // If the operation decrease the value below 0, the new value will be 0.
601 | static::assertEquals(4, $this->emulator->increment('key1', 1, 2));
602 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
603 | static::assertEquals(4, $this->emulator->get('key1'));
604 | }
605 |
606 | /**
607 | * @covers ::incrementByKey
608 | */
609 | public function testIncrementByKeyMissed()
610 | {
611 | // If the operation decrease the value below 0, the new value will be 0.
612 | static::assertEquals(3, $this->emulator->incrementByKey(static::SERVER_KEY, 'key1', 1, 2));
613 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
614 | static::assertEquals(3, $this->emulator->get('key1'));
615 | }
616 |
617 | /**
618 | * @covers ::increment
619 | */
620 | public function testIncrementByKeyExists()
621 | {
622 | static::assertTrue($this->emulator->set('key1', '3'));
623 |
624 | // If the operation decrease the value below 0, the new value will be 0.
625 | static::assertEquals(4, $this->emulator->incrementByKey(static::SERVER_KEY, 'key1', 1, 2));
626 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
627 | static::assertEquals(4, $this->emulator->get('key1'));
628 | }
629 |
630 | /**
631 | * @covers ::isPersistent
632 | */
633 | public function testIsPersistent()
634 | {
635 | static::assertFalse($this->emulator->isPersistent());
636 | }
637 |
638 | /**
639 | * @covers ::isPristine
640 | */
641 | public function testIsPristine()
642 | {
643 | static::assertTrue($this->emulator->isPristine());
644 | }
645 |
646 | /**
647 | * @covers ::prepend
648 | */
649 | public function testPrependExists()
650 | {
651 | static::assertTrue($this->emulator->set('key1', '1'));
652 | static::assertTrue($this->emulator->prepend('key1', '2'));
653 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
654 | static::assertEquals('21', $this->emulator->get('key1'));
655 | }
656 |
657 | /**
658 | * @covers ::appendByKey
659 | */
660 | public function testPrependByKeyMissed()
661 | {
662 | static::assertFalse($this->emulator->prependByKey(static::SERVER_KEY, 'key1', '2'));
663 | static::assertEquals(MemcachedEmulator::RES_NOTSTORED, $this->emulator->getResultCode());
664 | }
665 |
666 | /**
667 | * @covers ::quit
668 | */
669 | public function testQuit()
670 | {
671 | static::assertTrue($this->emulator->quit());
672 | }
673 |
674 | /**
675 | * @covers ::replace
676 | */
677 | public function testReplaceMissed()
678 | {
679 | static::assertFalse($this->emulator->replace('key1', '1'));
680 | static::assertEquals(MemcachedEmulator::RES_NOTSTORED, $this->emulator->getResultCode());
681 | }
682 |
683 | /**
684 | * @covers ::replace
685 | */
686 | public function testReplaceExists()
687 | {
688 | static::assertTrue($this->emulator->set('key1', '12'));
689 | static::assertTrue($this->emulator->replace('key1', '2'));
690 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
691 | }
692 |
693 | /**
694 | * @covers ::replaceByKey
695 | */
696 | public function testReplaceByKeyMissed()
697 | {
698 | static::assertFalse($this->emulator->replaceByKey(static::SERVER_KEY, 'key1', '1'));
699 | static::assertEquals(MemcachedEmulator::RES_NOTSTORED, $this->emulator->getResultCode());
700 | }
701 |
702 | /**
703 | * @covers ::replaceByKey
704 | */
705 | public function testReplaceByKeyExists()
706 | {
707 | static::assertTrue($this->emulator->setByKey(static::SERVER_KEY, 'key1', '1'));
708 | static::assertTrue($this->emulator->replaceByKey(static::SERVER_KEY, 'key1', '2'));
709 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
710 | }
711 |
712 | /**
713 | * @covers ::resetServerList
714 | */
715 | public function testResetServerList()
716 | {
717 | static::assertTrue($this->emulator->resetServerList());
718 | static::assertEquals([], $this->emulator->getServerList());
719 |
720 | $this->emulator->addServer('127.0.0.1', 11211);
721 | }
722 |
723 | /**
724 | * @covers ::set
725 | */
726 | public function testSet()
727 | {
728 | // Already covered in testGet()
729 | static::assertTrue(true);
730 | }
731 |
732 | /**
733 | * @covers ::setByKey
734 | */
735 | public function testSetByKey()
736 | {
737 | // Already covered in testGetByKey()
738 | static::assertTrue(true);
739 | }
740 |
741 | /**
742 | * @covers ::setMulti
743 | */
744 | public function testSetMulti()
745 | {
746 | // Already covered in testGetMulti()
747 | static::assertTrue(true);
748 | }
749 |
750 | /**
751 | * @covers ::setMultiByKey
752 | */
753 | public function testSetMultiByKey()
754 | {
755 | // Already covered in testGetMultiByKey()
756 | static::assertTrue(true);
757 | }
758 |
759 | /**
760 | * @covers ::setOption
761 | */
762 | public function testSetOption()
763 | {
764 | static::assertTrue($this->emulator->setOption(MemcachedEmulator::OPT_COMPRESSION, false));
765 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
766 |
767 | static::assertFalse($this->emulator->setOption(MemcachedEmulator::OPT_COMPRESSION_TYPE, 'invalid'));
768 | static::assertEquals(MemcachedEmulator::RES_INVALID_ARGUMENTS, $this->emulator->getResultCode());
769 |
770 | static::assertFalse($this->emulator->setOption(MemcachedEmulator::OPT_SERIALIZER, 'invalid'));
771 | static::assertEquals(MemcachedEmulator::RES_INVALID_ARGUMENTS, $this->emulator->getResultCode());
772 | }
773 |
774 | /**
775 | * @covers ::setOptions
776 | */
777 | public function testSetOptions()
778 | {
779 | static::assertTrue($this->emulator->setOptions([
780 | MemcachedEmulator::OPT_COMPRESSION => false,
781 | ]));
782 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
783 |
784 | static::assertFalse($this->emulator->setOptions([
785 | MemcachedEmulator::OPT_COMPRESSION => false,
786 | MemcachedEmulator::OPT_COMPRESSION_TYPE => 'invalid',
787 | ]));
788 | static::assertEquals(MemcachedEmulator::RES_INVALID_ARGUMENTS, $this->emulator->getResultCode());
789 | }
790 |
791 | /**
792 | * @covers ::setSaslAuthData
793 | */
794 | public function testSetSaslAuthData()
795 | {
796 | try {
797 | $this->emulator->setSaslAuthData('username', 'pass');
798 | } catch (\Exception $e) {
799 | static::assertInstanceOf(\BadMethodCallException::class, $e);
800 | }
801 | }
802 |
803 | /**
804 | * @covers ::touch
805 | */
806 | public function testTouch()
807 | {
808 | // Execute later, see testTouchExpiration.
809 | static::assertTrue(true);
810 | }
811 |
812 | /**
813 | * @covers ::touchByKey
814 | */
815 | public function testTouchByKey()
816 | {
817 | // Execute later, see testTouchByKeyExpiration.
818 | static::assertTrue(true);
819 | }
820 |
821 | /*
822 | * All time-related tests finally
823 | */
824 |
825 | /**
826 | * @covers ::flush
827 | */
828 | public function testFlushDelay()
829 | {
830 | static::assertTrue($this->emulator->set('key1', '1'));
831 | static::assertTrue($this->emulator->set('key2', '2'));
832 |
833 | static::assertTrue($this->emulator->flush(2));
834 | static::assertEquals(MemcachedEmulator::RES_SUCCESS, $this->emulator->getResultCode());
835 |
836 | static::assertEquals('1', $this->emulator->get('key1'));
837 | static::assertEquals('2', $this->emulator->get('key2'));
838 |
839 | \sleep(2);
840 |
841 | static::assertFalse($this->emulator->get('key1'));
842 | static::assertFalse($this->emulator->get('key2'));
843 | }
844 |
845 | /**
846 | * @covers ::set
847 | */
848 | public function testSetExpiration()
849 | {
850 | static::assertTrue($this->emulator->set('key1', '1', 1));
851 |
852 | \sleep(2);
853 |
854 | static::assertFalse($this->emulator->get('key1'));
855 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
856 | }
857 |
858 | /**
859 | * @covers ::set
860 | */
861 | public function testSetMultiExpiration()
862 | {
863 | static::assertTrue($this->emulator->setMulti(['key1' => '1', 'key2' => '2'], 1));
864 |
865 | \sleep(2);
866 |
867 | static::assertFalse($this->emulator->get('key1'));
868 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
869 |
870 | static::assertFalse($this->emulator->get('key2'));
871 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
872 | }
873 |
874 | /**
875 | * @covers ::touch
876 | */
877 | public function testTouchExpiration()
878 | {
879 | // Test touch availability.
880 | if (\version_compare($this->getClientVersion(), '1.4.8', '<')) {
881 | static::markTestSkipped('"touch" command available since memcached 1.4.8 only.');
882 | }
883 |
884 | static::assertFalse($this->emulator->touch('key1', 1));
885 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
886 |
887 | static::assertTrue($this->emulator->set('key1', 1));
888 | static::assertTrue($this->emulator->touch('key1', 1));
889 |
890 | \sleep(2);
891 |
892 | static::assertFalse($this->emulator->get('key1'));
893 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
894 | }
895 |
896 | /**
897 | * @covers ::touchByKey
898 | */
899 | public function testTouchByKeyExpiration()
900 | {
901 | // Test touch availability.
902 | if (\version_compare($this->getClientVersion(), '1.4.8', '<')) {
903 | static::markTestSkipped('"touch" command available since memcached 1.4.8 only.');
904 | }
905 |
906 | static::assertFalse($this->emulator->touchByKey(static::SERVER_KEY, 'key1', 1));
907 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
908 |
909 | static::assertTrue($this->emulator->setByKey(static::SERVER_KEY, 'key1', 1));
910 | static::assertTrue($this->emulator->touchByKey(static::SERVER_KEY, 'key1', 1));
911 |
912 | \sleep(2);
913 |
914 | static::assertFalse($this->emulator->getByKey(static::SERVER_KEY, 'key1'));
915 | static::assertEquals(MemcachedEmulator::RES_NOTFOUND, $this->emulator->getResultCode());
916 | }
917 |
918 | /**
919 | * @return array
920 | */
921 | protected static function getTestValues(): array
922 | {
923 | return [
924 | 'true' => true,
925 | 'false' => false,
926 | '0' => 0,
927 | '-1' => -1,
928 | 'null' => null,
929 | 'a' => 'a',
930 | 'END' => 'END',
931 | 'line_breaks' => "b\nEND\nb",
932 | 'empty_array' => [],
933 | 'array' => ['a'],
934 | 'object' => new \stdClass(),
935 | 'text' => \file_get_contents(__FILE__),
936 | __METHOD__ => __METHOD__,
937 | ];
938 | }
939 |
940 | /**
941 | * @param string $server_key
942 | * @return string|null
943 | */
944 | protected function getClientVersion($server_key = null): ?string
945 | {
946 | $server_key = $server_key ?? static::SERVER_KEY;
947 |
948 | $versions = $this->emulator->getVersion();
949 |
950 | return $versions[$server_key] ?? null;
951 | }
952 | }
953 |
--------------------------------------------------------------------------------