Lesson 7: test_can_pick_winner

[realglass]

Hi! to the end of lesson 7 , when I try to test "test_can_pick_winner" I am getting this error back. I am trying to deploy on rinkeby as instructed by the video.
Thank you so much for the help!

This is my code:

helpful scripts:
from brownie import (
network,
config,
accounts,
MockV3Aggregator,
Contract,
VRFCoordinatorMock,
LinkToken,
interface,
)

from web3 import Web3

FORKED_LOCAL_ENVIRONMENTS = ["mainnet-fork"]
LOCAL_BLOCKCHAIN_ENVIROMENTS = ["development", "ganache=local"]

DECIMALS = 8

STARTING_PRICE = 200000000000

contract_to_mock = {
"eth_usd_price_feed": MockV3Aggregator,
"vrf_coordinator": VRFCoordinatorMock,
"link_token": LinkToken,
}

def get_account(index=None, id=None):
if index:
return accounts[index]
if id:
return accounts.load(id)
if (
network.show_active() in LOCAL_BLOCKCHAIN_ENVIROMENTS
or network.show_active() in FORKED_LOCAL_ENVIRONMENTS
):
return accounts[0]

return accounts.add(config["wallets"]["from_key"])

def get_contract(contract_name):

contract_type = contract_to_mock[contract_name]
if network.show_active() in LOCAL_BLOCKCHAIN_ENVIROMENTS:
    if len(contract_type) <= 0:
        deploy_mocks()
    contract = contract_type[-1]
else:
    contract_address = config["networks"][network.show_active()][contract_name]

    contract = Contract.from_abi(
        contract_type._name, contract_address, contract_type.abi
    )
return contract

DECIMALS = 8
INITIAL_VALUE = 200000000000

def deploy_mocks(decimals=DECIMALS, initial_value=INITIAL_VALUE):
account = get_account()
MockV3Aggregator.deploy(decimals, initial_value, {"from": account})
link_token = LinkToken.deploy({"from": account})
VRFCoordinatorMock.deploy(link_token.address, {"from": account})
print("Deployed!")

def fund_with_link(
contract_address, account=None, link_token=None, amount=100000000000000000
): # 0.1 link
account = account if account else get_account()
link_token = link_token if link_token else get_contract("link_token")
tx = link_token.transfer(contract_address, amount, {"from": account})
# link_token_contract = interface.LinkTokenInterface(link_token.address)
# tx = link_token_contract.transfer(contract_address, amount, {"from": account})
tx.wait(1)
print("Fund contract!")
return tx

lottery contract:
//SPDX-License-Identifier: MIT
pragma solidity ^0.6.6;

import "@chainlink/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@chainlink/contracts/src/v0.6/VRFConsumerBase.sol";

contract Lottery is VRFConsumerBase, Ownable {
address payable[] public players;
address payable public recentWinner;
uint256 public usdEntryFee;
uint256 public randomness;

AggregatorV3Interface internal ethUsdPriceFeed;

enum LOTTERY_STATE {
    OPEN,
    CLOSED,
    CALCULATING_WINNER
}

LOTTERY_STATE public lottery_state;

uint256 public fee;
bytes32 public keyhash;
event RequestedRandomness(bytes32 requestID);

constructor(
    address _priceFeedAddress,
    address _vrfCoordinator,
    address _link,
    uint256 _fee,
    bytes32 _keyhash
) public VRFConsumerBase(_vrfCoordinator, _link) {
    usdEntryFee = 50 * (10**18);
    ethUsdPriceFeed = AggregatorV3Interface(_priceFeedAddress);
    lottery_state = LOTTERY_STATE.CLOSED;
    fee = _fee;
    keyhash = _keyhash;
}

function enter() public payable {
    require(lottery_state == LOTTERY_STATE.OPEN);
    require(msg.value >= getEntranceFee(), "Not enough ETH");
    players.push(msg.sender);
}

function getEntranceFee() public view returns (uint256) {
    (, int256 price, , , ) = ethUsdPriceFeed.latestRoundData();
    uint256 adjustedPrice = uint256(price) * 10**10;
    uint256 costToEnter = (usdEntryFee * 10**18) / adjustedPrice;
    return costToEnter;
}

function startLottery() public onlyOwner {
    require(
        lottery_state == LOTTERY_STATE.CLOSED,
        "Can't start a new lottery yet!"
    );

    lottery_state = LOTTERY_STATE.OPEN;
}

function endLottery() public onlyOwner {
    //     uint256(
    //         keccack256(
    //             abi.encodePacked(
    //                 nonce,
    //                 msg.sender,
    //                 block.difficulty,
    //                 block.timestamp
    //             )
    //         )
    //     ) % players.length;

    lottery_state = LOTTERY_STATE.CALCULATING_WINNER;
    bytes32 requestID = requestRandomness(keyhash, fee);
    emit RequestedRandomness(requestID);
}

function fulfillRandomness(bytes32 _requestId, uint256 _randomness)
    internal
    override
{
    require(
        lottery_state == LOTTERY_STATE.CALCULATING_WINNER,
        "You aren't there yet!"
    );

    require(_randomness > 0, "random-not-found");
    uint256 indexOfWinner = _randomness % players.length;
    recentWinner = players[indexOfWinner];
    recentWinner.transfer(address(this).balance);

    //Reset
    players = new address payable[](0);
    lottery_state = LOTTERY_STATE.CLOSED;
    randomness = _randomness;
}

}

test lottery integration:
from brownie import network
from scripts.helpful_scripts import (
LOCAL_BLOCKCHAIN_ENVIROMENTS,
get_account,
fund_with_link,
)
from scripts.deploy_lottery import deploy_lottery
import pytest
import time

def test_can_pick_winner():
if network.show_active() in LOCAL_BLOCKCHAIN_ENVIROMENTS:
pytest.skip()

lottery = deploy_lottery()
account = get_account()
lottery.startLottery({"from": account})
lottery.enter({"from": account, "value": lottery.getEntraceFee()})
lottery.enter({"from": account, "value": lottery.getEntraceFee()})
fund_with_link(lottery)
lottery.endLottery({"from": account})
time.sleep(60)
assert lottery.recentWinner() == account
assert lottery.balance() == 0

deploy lottery:
from scripts.helpful_scripts import get_account, get_contract, fund_with_link
from brownie import Lottery, network, config
import time

def deploy_lottery():
account = get_account()
lottery = Lottery.deploy(
get_contract("eth_usd_price_feed").address,
get_contract("vrf_coordinator").address,
get_contract("link_token").address,
config["networks"][network.show_active()]["fee"],
config["networks"][network.show_active()]["keyhash"],
{"from": account},
publish_source=config["networks"][network.show_active()].get("verify", False),
)
print("Deployed lottery!")
return lottery

def start_lottery():
account = get_account()
lottery = Lottery[-1]
starting_tx = lottery.startLottery({"from": account})
starting_tx.wait(1)
print("The lottery is started!")

def enter_lottery():
account = get_account()
lottery = Lottery[-1]
value = lottery.getEntranceFee() + 100000
tx = lottery.enter({"from": account, "value": value})
tx.wait(1)
print("You entered the lottery!")

def end_lottery():
account = get_account()
lottery = Lottery[-1]
tx = fund_with_link(lottery.address)
tx.wait(1)
ending_transaction = lottery.endLottery({"from": account})
ending_transaction.wait(1)
time.sleep(60)
print(f"{lottery.recentWinner()} is the new winner!")

# fund the contract
# then end the lottery

def main():
deploy_lottery()
start_lottery()
enter_lottery()
end_lottery()

[cromewar]

Hello @realglass
The error is because you have a typo on the name:
you have et_usd_price_feed and the correct one is:
eth_usd_price_feed

cheers.